PageRenderTime 73ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://bitbucket.org/chamilo/chamilo/
PHP | 2115 lines | 1344 code | 309 blank | 462 comment | 188 complexity | ca913e667e1afd5ef9c8573b8103cda4 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause, LGPL-2.1, LGPL-3.0, GPL-3.0, MIT

Large files files are truncated, but you can 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.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. 	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	$isSubPart			= false;	// indique que le convertisseur courant est un sous html

    36. 

  36. 

    37. 

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

    38. 

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

    39. 

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

    40. 

  40. 

    41. 

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

    42. 

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

    43. 

  43. 

    44. 

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

    45. 

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

    46. 

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

    47. 

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

    48. 

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

    49. 

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

    50. 

  50. 

    51. 

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

    52. 

  52. 

    53. 

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

    54. 

  54. 		protected	$defaultTop			= 0;

    55. 

  55. 		protected	$defaultRight		= 0;

    56. 

  56. 		protected	$defaultBottom		= 0;

    57. 

  57. 

    58. 

  58. 		protected	$margeLeft			= 0;		//marges r?elles de la page

    59. 

  59. 		protected	$margeTop			= 0;

    60. 

  60. 		protected	$margeRight			= 0;

    61. 

  61. 		protected	$margeBottom		= 0;

    62. 

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

    63. 

  63. 

    64. 

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

    65. 

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

    66. 

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

    67. 

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

    68. 

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

    69. 

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

    70. 

  70. 

    71. 

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

    72. 

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

    73. 

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

    74. 

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

    75. 

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

    76. 

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

    77. 

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

    78. 

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

    79. 

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

    80. 

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

    81. 

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

    82. 

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

    83. 

  83. 

    84. 

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

    85. 

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

    86. 

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

    87. 

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

    88. 

  88. 		protected	$DEBUG_start_time	= 0;		//

    89. 

  89. 		protected	$DEBUG_last_time	= 0;		//

    90. 

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

    91. 

  91. 

    92. 

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

    93. 

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

    94. 

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

    95. 

  95. 

    96. 

  96. 		/**

    97. 

  97. 		 * Constructeur

    98. 

  98. 		 *

    99. 

  99. 		 * @param	string		sens portrait ou landscape

    100. 

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

    101. 

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

    102. 

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

    103. 

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

    104. 

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

    105. 

  105. 		 * @return	null

    106. 

  106. 		 */

    107. 

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

    108. 

  108. 		{

    109. 

  109. 			// sauvegarde des param?tres

    110. 

  110. 			$this->page 		= 0;

    111. 

  111. 			$this->sens			= $sens;

    112. 

  112. 			$this->format		= $format;

    113. 

  113. 			$this->unicode		= $unicode;

    114. 

  114. 			$this->encoding		= $encoding;

    115. 

  115. 

    116. 

  116. 			$this->firstPage	= true;

    117. 

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

    118. 

  118. 

    119. 

  119. 			// chargement du fichier de langue

    120. 

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

    121. 

  121. 

    122. 

  122. 			// cr?ation de l' objet PDF

    123. 

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

    124. 

  124. 

    125. 

  125. 			// initialisation des styles

    126. 

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

    127. 

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

    128. 

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

    129. 

  129. 

    130. 

  130. 			// initialisations diverses

    131. 

  131. 			$this->setTestTdInOnePage(true);

    132. 

  132. 			$this->setTestIsImage(true);

    133. 

  133. 			$this->setDefaultFont(null);

    134. 

  134. 

    135. 

  135. 			// initialisation du parsing

    136. 

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

    137. 

  137. 			$this->sub_html = null;

    138. 

  138. 			$this->sub_part	= false;

    139. 

  139. 

    140. 

  140. 			// initialisation des marges

    141. 

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

    142. 

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

    143. 

  143. 			$this->setMargins();

    144. 

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

    145. 

  145. 

    146. 

  146. 			// initialisation des champs de formulaire

    147. 

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

    148. 

  148. 		}

    149. 

  149. 

    150. 

  150. 		/**

    151. 

  151. 		* Destructeur

    152. 

  152. 		*

    153. 

  153. 		* @return	null

    154. 

  154. 		*/

    155. 

  155. 		public function __destruct()

    156. 

  156. 		{

    157. 

  157. 

    158. 

  158. 		}

    159. 

  159. 

    160. 

  160. 		/**

    161. 

  161. 		* activer le debug mode

    162. 

  162. 		*

    163. 

  163. 		* @return	null

    164. 

  164. 		*/

    165. 

  165. 		public function setModeDebug()

    166. 

  166. 		{

    167. 

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

    168. 

  168. 

    169. 

  169. 			$this->DEBUG_actif = true;

    170. 

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

    171. 

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

    172. 

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

    173. 

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

    174. 

  174. 

    175. 

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

    176. 

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

    177. 

  177. 		}

    178. 

  178. 

    179. 

  179. 		/**

    180. 

  180. 		* rajouter une ligne de debug

    181. 

  181. 		*

    182. 

  182. 		* @param	string	nom de l'etape

    183. 

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

    184. 

  184. 		* @return	null

    185. 

  185. 		*/

    186. 

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

    187. 

  187. 		{

    188. 

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

    189. 

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

    190. 

  190. 

    191. 

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

    192. 

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

    193. 

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

    194. 

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

    195. 

  195. 

    196. 

  196. 			$this->DEBUG_stepline(

    197. 

  197. 						$nom,

    198. 

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

    199. 

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

    200. 

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

    201. 

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

    202. 

  202. 

    203. 

  203. 			$this->DEBUG_last_time = $time;

    204. 

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

    205. 

  205. 			return true;

    206. 

  206. 		}

    207. 

  207. 

    208. 

  208. 		/**

    209. 

  209. 		* affiche une ligne de debug

    210. 

  210. 		*

    211. 

  211. 		* @param	string	nom de l'etape

    212. 

  212. 		* @param	string	valeur 1

    213. 

  213. 		* @param	string	valeur 2

    214. 

  214. 		* @param	string	valeur 3

    215. 

  215. 		* @param	string	valeur 4

    216. 

  216. 		* @return	null

    217. 

  217. 		*/

    218. 

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

    219. 

  219. 		{

    220. 

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

    221. 

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

    222. 

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

    223. 

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

    224. 

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

    225. 

  225. 

    226. 

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

    227. 

  227. 		}

    228. 

  228. 

    229. 

  229. 		/**

    230. 

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

    231. 

  231. 		*

    232. 

  232. 		* @param	boolean	nouvel etat

    233. 

  233. 		* @return	boolean ancien etat

    234. 

  234. 		*/

    235. 

  235. 		public function setTestTdInOnePage($mode = true)

    236. 

  236. 		{

    237. 

  237. 			$old = $this->testTDin1page;

    238. 

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

    239. 

  239. 			return $old;

    240. 

  240. 		}

    241. 

  241. 

    242. 

  242. 		/**

    243. 

  243. 		* activer ou desactiver le test sur la pr?sence des images

    244. 

  244. 		*

    245. 

  245. 		* @param	boolean	nouvel etat

    246. 

  246. 		* @return	boolean ancien etat

    247. 

  247. 		*/

    248. 

  248. 		public function setTestIsImage($mode = true)

    249. 

  249. 		{

    250. 

  250. 			$old = $this->testIsImage;

    251. 

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

    252. 

  252. 			return $old;

    253. 

  253. 		}

    254. 

  254. 

    255. 

  255. 		/**

    256. 

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

    257. 

  257. 		*

    258. 

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

    259. 

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

    260. 

  260. 		*/

    261. 

  261. 		public function setDefaultFont($default = null)

    262. 

  262. 		{

    263. 

  263. 			$old = $this->defaultFont;

    264. 

  264. 			$this->defaultFont = $default;

    265. 

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

    266. 

  266. 			return $old;

    267. 

  267. 		}

    268. 

  268. 

    269. 

  269. 		/**

    270. 

  270. 		* d?finir les marges par d?fault

    271. 

  271. 		*

    272. 

  272. 		* @param	int		en mm, marge left

    273. 

  273. 		* @param	int		en mm, marge top

    274. 

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

    275. 

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

    276. 

  276. 		* @return	null

    277. 

  277. 		*/

    278. 

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

    279. 

  279. 		{

    280. 

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

    281. 

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

    282. 

  282. 

    283. 

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

    284. 

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

    285. 

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

    286. 

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

    287. 

  287. 		}

    288. 

  288. 

    289. 

  289. 		/**

    290. 

  290. 		* d?finir les marges r?elles, fonctions de la balise page

    291. 

  291. 		*

    292. 

  292. 		* @return	null

    293. 

  293. 		*/

    294. 

  294. 		protected function setMargins()

    295. 

  295. 		{

    296. 

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

    297. 

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

    298. 

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

    299. 

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

    300. 

  300. 

    301. 

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

    302. 

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

    303. 

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

    304. 

  304. 

    305. 

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

    306. 

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

    307. 

  307. 		}

    308. 

  308. 

    309. 

  309. 		/**

    310. 

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

    311. 

  311. 		*

    312. 

  312. 		* @param	float	y

    313. 

  313. 		* @return	array(float, float)

    314. 

  314. 		*/

    315. 

  315. 		protected function getMargins($y)

    316. 

  316. 		{

    317. 

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

    318. 

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

    319. 

  319. 

    320. 

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

    321. 

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

    322. 

  322. 

    323. 

  323. 			return $x;

    324. 

  324. 		}

    325. 

  325. 

    326. 

  326. 		/**

    327. 

  327. 		* ajouter une marge suite a un float

    328. 

  328. 		*

    329. 

  329. 		* @param	string	left ou right

    330. 

  330. 		* @param	float	x1

    331. 

  331. 		* @param	float	y1

    332. 

  332. 		* @param	float	x2

    333. 

  333. 		* @param	float	y2

    334. 

  334. 		* @return	null

    335. 

  335. 		*/

    336. 

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

    337. 

  337. 		{

    338. 

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

    339. 

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

    340. 

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

    341. 

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

    342. 

  342. 

    343. 

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

    344. 

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

    345. 

  345. 

    346. 

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

    347. 

  347. 			{

    348. 

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

    349. 

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

    350. 

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

    351. 

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

    352. 

  352. 			}

    353. 

  353. 

    354. 

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

    355. 

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

    356. 

  356. 

    357. 

  357. 			ksort($this->pageMarges);

    358. 

  358. 

    359. 

  359. 			$this->isAfterFloat = true;

    360. 

  360. 		}

    361. 

  361. 

    362. 

  362. 		/**

    363. 

  363. 		* d?finir des nouvelles marges et sauvegarder les anciennes

    364. 

  364. 		*

    365. 

  365. 		* @param	float	marge left

    366. 

  366. 		* @param	float	marge top

    367. 

  367. 		* @param	float	marge right

    368. 

  368. 		* @return	null

    369. 

  369. 		*/

    370. 

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

    371. 

  371. 		{

    372. 

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

    373. 

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

    374. 

  374. 

    375. 

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

    376. 

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

    377. 

  377. 		}

    378. 

  378. 

    379. 

  379. 		/**

    380. 

  380. 		* r?cuperer les derni?res marches sauv?es

    381. 

  381. 		*

    382. 

  382. 		* @return	null

    383. 

  383. 		*/

    384. 

  384. 		protected function loadMargin()

    385. 

  385. 		{

    386. 

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

    387. 

  387. 			if ($old)

    388. 

  388. 			{

    389. 

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

    390. 

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

    391. 

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

    392. 

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

    393. 

  393. 			}

    394. 

  394. 			else

    395. 

  395. 			{

    396. 

  396. 				$ml = $this->margeLeft;

    397. 

  397. 				$mt = 0;

    398. 

  398. 				$mr = $this->margeRight;

    399. 

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

    400. 

  400. 			}

    401. 

  401. 

    402. 

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

    403. 

  403. 			$this->pageMarges = $mP;

    404. 

  404. 		}

    405. 

  405. 

    406. 

  406. 		/**

    407. 

  407. 		* permet d'ajouter une fonte.

    408. 

  408. 		*

    409. 

  409. 		* @param	string nom de la fonte

    410. 

  410. 		* @param	string style de la fonte

    411. 

  411. 		* @param	string fichier de la fonte

    412. 

  412. 		* @return	null

    413. 

  413. 		*/

    414. 

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

    415. 

  415. 		{

    416. 

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

    417. 

  417. 		}

    418. 

  418. 

    419. 

  419. 		/**

    420. 

  420. 		* sauvegarder l'?tat actuelle des maximums

    421. 

  421. 		*

    422. 

  422. 		* @return	null

    423. 

  423. 		*/

    424. 

  424. 		protected function saveMax()

    425. 

  425. 		{

    426. 

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

    427. 

  427. 		}

    428. 

  428. 

    429. 

  429. 		/**

    430. 

  430. 		* charger le dernier ?tat sauv? des maximums

    431. 

  431. 		*

    432. 

  432. 		* @return	null

    433. 

  433. 		*/

    434. 

  434. 		protected function loadMax()

    435. 

  435. 		{

    436. 

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

    437. 

  437. 

    438. 

  438. 			if ($old)

    439. 

  439. 			{

    440. 

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

    441. 

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

    442. 

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

    443. 

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

    444. 

  444. 			}

    445. 

  445. 			else

    446. 

  446. 			{

    447. 

  447. 				$this->maxX = 0;

    448. 

  448. 				$this->maxY = 0;

    449. 

  449. 				$this->maxH = 0;

    450. 

  450. 				$this->maxE = 0;

    451. 

  451. 			}

    452. 

  452. 		}

    453. 

  453. 

    454. 

  454. 		/**

    455. 

  455. 		* afficher l'header contenu dans page_header

    456. 

  456. 		*

    457. 

  457. 		* @return	null

    458. 

  458. 		*/

    459. 

  459. 		protected function setPageHeader()

    460. 

  460. 		{

    461. 

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

    462. 

  462. 

    463. 

  463. 			$OLD_parse_pos = $this->parse_pos;

    464. 

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

    465. 

  465. 

    466. 

  466. 			$this->parse_pos = 0;

    467. 

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

    468. 

  468. 			$this->makeHTMLcode();

    469. 

  469. 

    470. 

  470. 			$this->parse_pos = 	$OLD_parse_pos;

    471. 

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

    472. 

  472. 		}

    473. 

  473. 

    474. 

  474. 		/**

    475. 

  475. 		* afficher le footer contenu dans page_footer

    476. 

  476. 		*

    477. 

  477. 		* @return	null

    478. 

  478. 		*/

    479. 

  479. 		protected function setPageFooter()

    480. 

  480. 		{

    481. 

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

    482. 

  482. 

    483. 

  483. 			$OLD_parse_pos = $this->parse_pos;

    484. 

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

    485. 

  485. 

    486. 

  486. 			$this->parse_pos = 0;

    487. 

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

    488. 

  488. 			$this->isInFooter = true;

    489. 

  489. 			$this->makeHTMLcode();

    490. 

  490. 			$this->isInFooter = false;

    491. 

  491. 

    492. 

  492. 			$this->parse_pos = 	$OLD_parse_pos;

    493. 

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

    494. 

  494. 		}

    495. 

  495. 

    496. 

  496. 		/**

    497. 

  497. 		* saut de ligne avec une hauteur sp?cifique

    498. 

  498. 		*

    499. 

  499. 		* @param	float	hauteur de la ligne

    500. 

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

    501. 

  501. 		* @return	null

    502. 

  502. 		*/

    503. 

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

    504. 

  504. 		{

    505. 

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

    506. 

  506. 

    507. 

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

    508. 

  508. 		}

    509. 

  509. 

    510. 

  510. 		/**

    511. 

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

    512. 

  512. 		*

    513. 

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

    514. 

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

    515. 

  515. 		* @param	array	tableau des propri?t?s du fond de la page

    516. 

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

    517. 

  517. 		* @return	null

    518. 

  518. 		*/

    519. 

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

    520. 

  520. 		{

    521. 

  521. 			$this->firstPage = false;

    522. 

  522. 

    523. 

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

    524. 

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

    525. 

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

    526. 

  526. 			$this->maxY = 0;

    527. 

  527. 			$this->maxX = 0;

    528. 

  528. 			$this->maxH = 0;

    529. 

  529. 

    530. 

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

    531. 

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

    532. 

  532. 			$this->page++;

    533. 

  533. 

    534. 

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

    535. 

  535. 			{

    536. 

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

    537. 

  537. 				{

    538. 

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

    539. 

  539. 					{

    540. 

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

    541. 

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

    542. 

  542. 					}

    543. 

  543. 

    544. 

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

    545. 

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

    546. 

  546. 				}

    547. 

  547. 

    548. 

  548. 				$this->setPageHeader();

    549. 

  549. 				$this->setPageFooter();

    550. 

  550. 			}

    551. 

  551. 

    552. 

  552. 			$this->setMargins();

    553. 

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

    554. 

  554. 

    555. 

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

    556. 

  556. 			$this->maxH = 0;

    557. 

  557. 		}

    558. 

  558. 

    559. 

  559. 		/**

    560. 

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

    561. 

  561. 		*

    562. 

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

    563. 

  563. 		* @return	null

    564. 

  564. 		*/

    565. 

  565. 		protected function setNewPositionForNewLine($curr = null)

    566. 

  566. 		{

    567. 

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

    568. 

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

    569. 

  569. 			$wMax = $rx-$lx;

    570. 

  570. 			$this->currentH = 0;

    571. 

  571. 

    572. 

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

    573. 

  573. 			{

    574. 

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

    575. 

  575. 				return null;

    576. 

  576. 			}

    577. 

  577. /*

    578. 

  578. 			if (

    579. 

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

    580. 

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

    581. 

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

    582. 

  582. 				)

    583. 

  583. 			{

    584. 

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

    585. 

  585. 				return null;

    586. 

  586. 			}

    587. 

  587. */

    588. 

  588. 			$sub = null;

    589. 

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

    590. 

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

    591. 

  591. 			$sub->forOneLine = true;

    592. 

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

    593. 

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

    594. 

  594. 

    595. 

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

    596. 

  596. 			{

    597. 

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

    598. 

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

    599. 

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

    600. 

  600. 			}

    601. 

  601. 			else

    602. 

  602. 				$sub->parse_pos++;

    603. 

  603. 

    604. 

  604. 			// pour chaque element identifi? par le parsing

    605. 

  605. 			$res = null;

    606. 

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

    607. 

  607. 			{

    608. 

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

    609. 

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

    610. 

  610. 				if (!$res) break;

    611. 

  611. 			}

    612. 

  612. 

    613. 

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

    614. 

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

    615. 

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

    616. 

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

    617. 

  617. 

    618. 

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

    619. 

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

    620. 

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

    621. 

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

    622. 

  622. 			else

    623. 

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

    624. 

  624. 

    625. 

  625. 			$this->currentH = $h;

    626. 

  626. /*

    627. 

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

    628. 

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

    629. 

  629. 			else

    630. 

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

    631. 

  631. */

    632. 

  632. 		}

    633. 

  633. 

    634. 

  634. 		/**

    635. 

  635. 		* r?cup?ration du PDF

    636. 

  636. 		*

    637. 

  637. 		* @param	string	nom du fichier PDF

    638. 

  638. 		* @param	boolean	destination

    639. 

  639. 		* @return	string	contenu ?ventuel du pdf

    640. 

  640. 		*

    641. 

  641. 		*

    642. 

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

    643. 

  643. 		* true	: equivalent ? I

    644. 

  644. 		* false	: equivalent ? S

    645. 

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

    646. 

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

    647. 

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

    648. 

  648. 		* S : renvoyer le document sous forme de cha?ne. name est ignor?.

    649. 

  649. 		*/

    650. 

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

    651. 

  651. 		{

    652. 

  652. 			// nettoyage

    653. 

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

    654. 

  654. 

    655. 

  655. 			if ($this->DEBUG_actif)

    656. 

  656. 			{

    657. 

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

    658. 

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

    659. 

  659. 				exit;

    660. 

  660. 			}

    661. 

  661. 

    662. 

  662. 			// interpretation des param?tres

    663. 

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

    664. 

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

    665. 

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

    666. 

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

    667. 

  667. 

    668. 

  668. 			// verification de la destination

    669. 

  669. 			$dest = strtoupper($dest);

    670. 

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

    671. 

  671. 

    672. 

  672. 			// verification du nom

    673. 

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

    674. 

  674. 			{

    675. 

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

    676. 

  676. 				exit;

    677. 

  677. 			}

    678. 

  678. 

    679. 

  679. 

    680. 

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

    681. 

  681. 		}

    682. 

  682. 

    683. 

  683. 		/**

    684. 

  684. 		* preparation de HTML2PDF::$SUBOBJ utilis? pour la cr?ation des sous HTML2PDF

    685. 

  685. 		*

    686. 

  686. 		* @return	null

    687. 

  687. 		*/

    688. 

  688. 		protected function prepareSubObj()

    689. 

  689. 		{

    690. 

  690. 			$pdf = null;

    691. 

  691. 

    692. 

  692. 			HTML2PDF::$SUBOBJ = new HTML2PDF(

    693. 

  693. 										$this->sens,

    694. 

  694. 										$this->format,

    695. 

  695. 										$this->langue,

    696. 

  696. 										$this->unicode,

    697. 

  697. 										$this->encoding,

    698. 

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

    699. 

  699. 									);

    700. 

  700. 

    701. 

  701. 			// initialisation

    702. 

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

    703. 

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

    704. 

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

    705. 

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

    706. 

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

    707. 

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

    708. 

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

    709. 

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

    710. 

  710. 		}

    711. 

  711. 

    712. 

  712. 		/**

    713. 

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

    714. 

  714. 		*

    715. 

  715. 		* @return	null

    716. 

  716. 		*/

    717. 

  717. 		public function __clone()

    718. 

  718. 		{

    719. 

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

    720. 

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

    721. 

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

    722. 

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

    723. 

  723. 		}

    724. 

  724. 

    725. 

  725.  		/**

    726. 

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

    727. 

  727. 		*

    728. 

  728. 		* @param	HTML2PDF	futur sous HTML2PDF pass? en r?f?rence pour cr?ation

    729. 

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

    730. 

  730. 		* @return	null

    731. 

  731. 		*/

    732. 

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

    733. 

  733. 		{

    734. 

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

    735. 

  735. 

    736. 

  736. 			// calcul de la largueur

    737. 

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

    738. 

  738. 			{

    739. 

  739. 				$marge = $cellmargin*2;

    740. 

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

    741. 

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

    742. 

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

    743. 

  743. 			}

    744. 

  744. 			else

    745. 

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

    746. 

  746. 

    747. 

  747. 			//clonage

    748. 

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

    749. 

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

    750. 

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

    751. 

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

    752. 

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

    753. 

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

    754. 

  754. 		}

    755. 

  755. 

    756. 

  756. 		/**

    757. 

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

    758. 

  758. 		*

    759. 

  759. 		* @return	null

    760. 

  760. 		*/

    761. 

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

    762. 

  762. 		{

    763. 

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

    764. 

  764. 			$this->defLIST = $defLIST;

    765. 

  765. 

    766. 

  766. 			$this->page = $page;

    767. 

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

    768. 

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

    769. 

  769. 		}

    770. 

  770. 

    771. 

  771. 		public function setIsSubPart()

    772. 

  772. 		{

    773. 

  773. 			$this->isSubPart  = true;

    774. 

  774. 		}

    775. 

  775. 

    776. 

  776. 		/**

    777. 

  777. 		* destruction d'un sous HTML2PDF pour la gestion des tableaux imbriqu?s

    778. 

  778. 		*

    779. 

  779. 		* @return	null

    780. 

  780. 		*/

    781. 

  781. 		protected function destroySubHTML(&$sub_html)

    782. 

  782. 		{

    783. 

  783. 			unset($sub_html);

    784. 

  784. 			$sub_html = null;

    785. 

  785. 		}

    786. 

  786. 

    787. 

  787. 		/**

    788. 

  788. 		* Convertir un nombre arabe en nombre romain

    789. 

  789. 		*

    790. 

  790. 		* @param	integer	nombre ? convertir

    791. 

  791. 		* @return	string	nombre converti

    792. 

  792. 		*/

    793. 

  793. 		protected function listeArab2Rom($nb_ar)

    794. 

  794. 		{

    795. 

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

    796. 

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

    797. 

  797. 			$nb_ro	= '';

    798. 

  798. 

    799. 

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

    800. 

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

    801. 

  801. 

    802. 

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

    803. 

  803. 			{

    804. 

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

    805. 

  805. 				if($chiffre>=1)

    806. 

  806. 				{

    807. 

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

    808. 

  808. 					if($chiffre<=3)

    809. 

  809. 					{

    810. 

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

    811. 

  811. 						{

    812. 

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

    813. 

  813. 						}

    814. 

  814. 					}

    815. 

  815. 					else if($chiffre==9)

    816. 

  816. 					{

    817. 

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

    818. 

  818. 					}

    819. 

  819. 					elseif($chiffre==4)

    820. 

  820. 					{

    821. 

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

    822. 

  822. 					}

    823. 

  823. 					else

    824. 

  824. 					{

    825. 

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

    826. 

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

    827. 

  827. 						{

    828. 

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

    829. 

  829. 						}

    830. 

  830. 					}

    831. 

  831. 				}

    832. 

  832. 			}

    833. 

  833. 			return $nb_ro;

    834. 

  834. 		}

    835. 

  835. 

    836. 

  836. 		/**

    837. 

  837. 		* Ajouter un LI au niveau actuel

    838. 

  838. 		*

    839. 

  839. 		* @return	null

    840. 

  840. 		*/

    841. 

  841. 		protected function listeAddLi()

    842. 

  842. 		{

    843. 

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

    844. 

  844. 		}

    845. 

  845. 

    846. 

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

    847. 

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

    848. 

  848. 

    849. 

  849. 		/**

    850. 

  850. 		* Recuperer le LI du niveau actuel

    851. 

  851. 		*

    852. 

  852. 		* @return	string	chaine ? afficher

    853. 

  853. 		*/

    854. 

  854. 		protected function listeGetLi()

    855. 

  855. 		{

    856. 

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

    857. 

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

    858. 

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

    859. 

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

    860. 

  860. 

    861. 

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

    862. 

  862. 

    863. 

  863. 			switch($st)

    864. 

  864. 			{

    865. 

  865. 				case 'none':

    866. 

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

    867. 

  867. 

    868. 

  868. 				case 'upper-alpha':

    869. 

  869. 				case 'lower-alpha':

    870. 

  870. 					$str = '';

    871. 

  871. 					while($nb>26)

    872. 

  872. 					{

    873. 

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

    874. 

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

    875. 

  875. 					}

    876. 

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

    877. 

  877. 

    878. 

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

    879. 

  879. 

    880. 

  880. 				case 'upper-roman':

    881. 

  881. 				case 'lower-roman':

    882. 

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

    883. 

  883. 

    884. 

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

    885. 

  885. 

    886. 

  886. 				case 'decimal':

    887. 

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

    888. 

  888. 

    889. 

  889. 				case 'square':

    890. 

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

    891. 

  891. 

    892. 

  892. 				case 'circle':

    893. 

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

    894. 

  894. 

    895. 

  895. 				case 'disc':

    896. 

  896. 				default:

    897. 

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

    898. 

  898. 			}

    899. 

  899. 		}

    900. 

  900. 

    901. 

  901. 		/**

    902. 

  902. 		* Ajouter un niveau de liste

    903. 

  903. 		*

    904. 

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

    905. 

  905. 		* @param	string	style de la liste

    906. 

  906. 		* @return	null

    907. 

  907. 		*/

    908. 

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

    909. 

  909. 		{

    910. 

  910. 			if ($img)

    911. 

  911. 			{

    912. 

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

    913. 

  913. 					$img = $match[1];

    914. 

  914. 				else

    915. 

  915. 					$img = null;

    916. 

  916. 			}

    917. 

  917. 			else

    918. 

  918. 				$img = null;

    919. 

  919. 

    920. 

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

    921. 

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

    922. 

  922. 

    923. 

  923. 			if (!$style)

    924. 

  924. 			{

    925. 

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

    926. 

  926. 				else				$style = 'decimal';

    927. 

  927. 			}

    928. 

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

    929. 

  929. 		}

    930. 

  930. 

    931. 

  931. 		/**

    932. 

  932. 		* Supprimer un niveau de liste

    933. 

  933. 		*

    934. 

  934. 		* @return	null

    935. 

  935. 		*/

    936. 

  936. 		protected function listeDelLevel()

    937. 

  937. 		{

    938. 

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

    939. 

  939. 			{

    940. 

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

    941. 

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

    942. 

  942. 			}

    943. 

  943. 		}

    944. 

  944. 

    945. 

  945. 		/**

    946. 

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

    947. 

  947. 		*

    948. 

  948. 		* @param	string	code HTML ? convertir

    949. 

  949. 		* @param	boolean	afficher en pdf (false) ou en html adapt? (true)

    950. 

  950. 		* @return	null

    951. 

  951. 		*/

    952. 

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

    953. 

  953. 		{

    954. 

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

    955. 

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

    956. 

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

    957. 

  957. 

    958. 

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

    959. 

  959. 

    960. 

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

    961. 

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

    962. 

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

    963. 

  963. 

    964. 

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

    965. 

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

    966. 

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

    967. 

  967. 

    968. 

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

    969. 

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

    970. 

  970. 

    971. 

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

    972. 

  972. 			// parsing

    973. 

  973. 			$this->sub_pdf = false;

    974. 

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

    975. 

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

    976. 

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

    977. 

  977. 			$this->makeHTMLcode();

    978. 

  978. 		}

    979. 

  979. 

    980. 

  980. 		/**

    981. 

  981. 		* traitement du code d'une vrai page HTML pour l'adapter ? HTML2PDF

    982. 

  982. 		*

    983. 

  983. 		* @param	string	code HTML ? adapter

    984. 

  984. 		* @return	string	code HTML adapt?

    985. 

  985. 		*/

    986. 

  986. 		public function getHtmlFromPage($html)

    987. 

  987. 		{

    988. 

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

    989. 

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

    990. 

  990. 

    991. 

  991. 			// extraction du contenu

    992. 

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

    993. 

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

    994. 

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

    995. 

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

    996. 

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

    997. 

  997. 

    998. 

  998. 			// extraction des balises link

    999. 

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

    1000. 

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

    1001. 

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

    1002. 

  1002. 

    1003. 

  1003. 			// extraction des balises style

    1004. 

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

    1005. 

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

    1006. 

  1006. 				$content = $src.$content;

    1007. 

  1007. 

    1008. 

  1008. 			return $content;

    1009. 

  1009. 		}

    1010. 

  1010. 

    1011. 

  1011. 		/**

    1012. 

  1012. 		* execute les diff?rentes actions du code HTML

    1013. 

  1013. 		*

    1014. 

  1014. 		* @return	null

    1015. 

  1015. 		*/

    1016. 

  1016. 		protected function makeHTMLcode()

    1017. 

  1017. 		{

    1018. 

  1018. 			// pour chaque element identifi? par le parsing

    1019. 

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

    1020. 

  1020. 			{

    1021. 

  1021. 				// r?cup?ration de l'?l?ment

    1022. 

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

    1023. 

  1023. 

    1024. 

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

    1025. 

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

    1026. 

  1026. 				{

    1027. 

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

    1028. 

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

    1029. 

  1029. 

    1030. 

  1030. 					$this->sub_part = true;

    1031. 

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

    1032. 

  1032. 

    1033. 

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

    1034. 

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

    1035. 

  1035. 					{

    1036. 

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

    1037. 

  1037. 						$this->temp_pos++;

    1038. 

  1038. 					}

    1039. 

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

    1040. 

  1040. 					$this->sub_part = false;

    1041. 

  1041. 				}

    1042. 

  1042. 

    1043. 

  1043. 				// chargement de l'action correspondant ? l'?l?ment

    1044. 

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

    1045. 

  1045. 			}

    1046. 

  1046. 		}

    1047. 

  1047. 

    1048. 

  1048. 

    1049. 

  1049. 

    1050. 

  1050. 		/**

    1051. 

  1051. 		* affichage en mode HTML du contenu

    1052. 

  1052. 		*

    1053. 

  1053. 		* @param	string	contenu

    1054. 

  1054. 		* @return	null

    1055. 

  1055. 		*/

    1056. 

  1056. 		protected function vueHTML($content)

    1057. 

  1057. 		{

    1058. 

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

    1059. 

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

    1060. 

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

    1061. 

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

    1062. 

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

    1063. 

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

    1064. 

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

    1065. 

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

    1066. 

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

    1067. 

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

    1068. 

  1068. 

    1069. 

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

    1070. 

  1070. <html>

    1071. 

  1071. 	<head>

    1072. 

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

    1073. 

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

    1074. 

  1074. 	</head>

    1075. 

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

    1076. 

  1076. '.$content.'

    1077. 

  1077. 	</body>

    1078. 

  1078. </html>';

    1079. 

  1079. 			exit;

    1080. 

  1080. 		}

    1081. 

  1081. 

    1082. 

  1082. 		/**

    1083. 

  1083. 		* chargement de l'action correspondante ? un element de parsing

    1084. 

  1084. 		*

    1085. 

  1085. 		* @param	array	?l?ment de parsing

    1086. 

  1086. 		* @return	null

    1087. 

  1087. 		*/

    1088. 

  1088. 		protected function loadAction($row)

    1089. 

  1089. 		{

    1090. 

  1090. 			// nom de l'action

    1091. 

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

    1092. 

  1092. 

    1093. 

  1093. 			// parametres de l'action

    1094. 

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

    1095. 

  1095. 

    1096. 

  1096. 			// si aucune page n'est cr??, on la cr??

    1097. 

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

    1098. 

  1098. 			{

    1099. 

  1099. 				$this->setNewPage();

    1100. 

  1100. 			}

    1101. 

  1101. 

    1102. 

  1102. 			// lancement de l'action

    1103. 

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

    1104. 

  1104. 			{

    1105. 

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

    1106. 

  1106. 				$this->previousCall = $fnc;

    1107. 

  1107. 				return $res;

    1108. 

  1108. 			}

    1109. 

  1109. 			else

    1110. 

  1110. 			{

    1111. 

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

    1112. 

  1112. 				return false;

    1113. 

  1113. 			}

    1114. 

  1114. 		}

    1115. 

  1115. 

    1116. 

  1116. 		/**

    1117. 

  1117. 		* balise	: PAGE

    1118. 

  1118. 		* mode		: OUVERTURE

    1119. 

  1119. 		*

    1120. 

  1120. 		* @param	array	param?tres de l'?l?ment de parsing

    1121. 

  1121. 		* @return	null

    1122. 

  1122. 		*/

    1123. 

  1123. 		protected function o_PAGE($param)

    1124. 

  1124. 		{

    1125. 

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

    1126. 

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

    1127. 

  1127. 

    1128. 

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

    1129. 

  1129. 

    1130. 

  1130. 			$this->maxH = 0;

    1131. 

  1131. 			if ($newPageSet)

    1132. 

  1132. 			{

    1133. 

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

    1134. 

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

    1135. 

  1135. 

    1136. 

  1136. 				// identification de l'orientation demand?e

    1137. 

  1137. 				$orientation = '';

    1138. 

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

    1139. 

  1139. 				{

    1140. 

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

    1141. 

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

    1142. 

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

    1143. 

  1143. 

    1144. 

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

    1145. 

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

    1146. 

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

    1147. 

  1147. 				}

    1148. 

  1148. 

    1149. 

  1149. 				// identification de l'orientation demand?e

    1150. 

  1150. 				$format = null;

    1151. 

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

    1152. 

  1152. 				{

    1153. 

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

    1154. 

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

    1155. 

  1155. 					{

    1156. 

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

    1157. 

  1157. 					}

    1158. 

  1158. 				}

    1159. 

  1159. 

    1160. 

  1160. 				// identification des propri?t?s du background

    1161. 

  1161. 				$background = array();

    1162. 

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

    1163. 

  1163. 				{

    1164. 

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

    1165. 

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

    1166. 

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

    1167. 

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

    1168. 

  1168. 

    1169. 

  1169. 					// conversion du nom de l'image, en cas de param?tres en _GET

    1170. 

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

    1171. 

  1171. 					// conversion des positions

    1172. 

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

    1173. 

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

    1174. 

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

    1175. 

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

    1176. 

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

    1177. 

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

    1178. 

  1178. 

    1179. 

  1179. 

    1180. 

  1180. 					// si il y a une image de pr?cis?

    1181. 

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

    1182. 

  1182. 					{

    1183. 

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

    1184. 

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

    1185. 

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

    1186. 

  1186. 						{

    1187. 

  1187. 							// taille de l'image, en fonction de la taille sp?cifi?e.

    1188. 

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

    1189. 

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

    1190. 

  1190. 

    1191. 

  1191. 							// r?cup?ration des dimensions et positions de l'image

    1192. 

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

    1193. 

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

    1194. 

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

    1195. 

  1195. 						}

    1196. 

  1196. 						else

    1197. 

  1197. 							$background = array();

    1198. 

  1198. 					}

    1199. 

  1199. 					else

    1200. 

  1200. 						$background = array();

    1201. 

  1201. 				}

    1202. 

  1202. 

    1203. 

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

    1204. 

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

    1205. 

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

    1206. 

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

    1207. 

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

    1208. 

  1208. 

    1209. 

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

    1210. 

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

    1211. 

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

    1212. 

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

    1213. 

  1213. 

    1214. 

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

    1215. 

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

    1216. 

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

    1217. 

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

    1218. 

  1218. 

    1219. 

  1219. 				$res = false;

    1220. 

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

    1221. 

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

    1222. 

  1222. 

    1223. 

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

    1224. 

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

    1225. 

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

    1226. 

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

    1227. 

  1227. 

    1228. 

  1228. 				// nouvelle page

    1229. 

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

    1230. 

  1230. 

    1231. 

  1231. 				// footer automatique

    1232. 

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

    1233. 

  1233. 				{

    1234. 

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

    1235. 

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

    1236. 

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

    1237. 

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

    1238. 

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

    1239. 

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

    1240. 

  1240. 				}

    1241. 

  1241. 				else

    1242. 

  1242. 				{

    1243. 

  1243. 					$page	= null;

    1244. 

  1244. 					$date	= null;

    1245. 

  1245. 					$heure	= null;

    1246. 

  1246. 					$form	= null;

    1247. 

  1247. 				}

    1248. 

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

    1249. 

  1249. 			}

    1250. 

  1250. 			else

    1251. 

  1251. 			{

    1252. 

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

    1253. 

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

    1254. 

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

    1255. 

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

    1256. 

  1256. 

    1257. 

  1257. 				$this->setNewPage();

    1258. 

  1258. 			}

    1259. 

  1259. 

    1260. 

  1260. 			return true;

    1261. 

  1261. 		}

    1262. 

  1262. 

    1263. 

  1263. 		/**

    1264. 

  1264. 		* balise : PAGE

    1265. 

  1265. 		* mode : FERMETURE

    1266. 

  1266. 		*

    1267. 

  1267. 		* @param	array	param?tres de l'?l?ment de parsing

    1268. 

  1268. 		* @return	null

    1269. 

  1269. 		*/

    1270. 

  1270. 		protected function c_PAGE($param)

    1271. 

  1271. 		{

    1272. 

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

    1273. 

  1273. 

    1274. 

  1274. 			$this->maxH = 0;

    1275. 

  1275. 

    1276. 

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

    1277. 

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

    1278. 

  1278. 

    1279. 

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

    1280. 

  1280. 

    1281. 

  1281. 			return true;

    1282. 

  1282. 		}

    1283. 

  1283. 

    1284. 

  1284. 

    1285. 

  1285. 		protected function o_PAGE_HEADER($param)

    1286. 

  1286. 		{

    1287. 

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

    1288. 

  1288. 

    1289. 

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

    1290. 

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

    1291. 

  1291. 			{

    1292. 

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

    1293. 

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

    1294. 

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

    1295. 

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

    1296. 

  1296. 			}

    1297. 

  1297. 

    1298. 

  1298. 			$this->setPageHeader();

    1299. 

  1299. 

    1300. 

  1300. 			return true;

    1301. 

  1301. 		}

    1302. 

  1302. 

    1303. 

  1303. 		protected function o_PAGE_FOOTER($param)

    1304. 

  1304. 		{

    1305. 

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

    1306. 

  1306. 

    1307. 

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

    1308. 

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

    1309. 

  1309. 			{

    1310. 

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

    1311. 

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

    1312. 

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

    1313. 

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

    1314. 

  1314. 			}

    1315. 

  1315. 

    1316. 

  1316. 			$this->setPageFooter();

    1317. 

  1317. 

    1318. 

  1318. 			return true;

    1319. 

  1319. 		}

    1320. 

  1320. 

    1321. 

  1321. 		protected function o_PAGE_HEADER_SUB($param)

    1322. 

  1322. 		{

    1323. 

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

    1324. 

  1324. 

    1325. 

  1325. 			// sauvegarde de l'?tat

    1326. 

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

    1327. 

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

    1328. 

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

    1329. 

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

    1330. 

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

    1331. 

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

    1332. 

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

    1333. 

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

    1334. 

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

    1335. 

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

    1336. 

  1336. 

    1337. 

  1337. 			// nouvel etat pour le footer

    1338. 

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

    1339. 

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

    1340. 

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

    1341. 

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

    1342. 

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

    1343. 

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

    1344. 

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

    1345. 

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

    1346. 

  1346. 

    1347. 

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

    1348. 

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

    1349. 

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

    1350. 

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

    1351. 

  1351. 

    1352. 

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

    1353. 

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

    1354. 

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

    1355. 

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

    1356. 

  1356. 			$this->setNewPositionForNewLine();

    1357. 

  1357. 			return true;

    1358. 

  1358. 		}

    1359. 

  1359. 

    1360. 

  1360. 		protected function c_PAGE_HEADER_SUB($param)

    1361. 

  1361. 		{

    1362. 

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

    1363. 

  1363. 

    1364. 

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

    1365. 

  1365. 

    1366. 

  1366. 			// retablissement de l'etat

    1367. 

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

    1368. 

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

    1369. 

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

    1370. 

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

    1371. 

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

    1372. 

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

    1373. 

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

    1374. 

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

    1375. 

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

    1376. 

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

    1377. 

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

    1378. 

  1378. 

    1379. 

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

    1380. 

  1380. 			$this->maxH = 0;

    1381. 

  1381. 

    1382. 

  1382. 			return true;

    1383. 

  1383. 		}

    1384. 

  1384. 

    1385. 

  1385. 		protected function o_PAGE_FOOTER_SUB($param)

    1386. 

  1386. 		{

    1387. 

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

    1388. 

  1388. 

    1389. 

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

    1390. 

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

    1391. 

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

    1392. 

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

    1393. 

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

    1394. 

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

    1395. 

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

    1396. 

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

    1397. 

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

    1398. 

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

    1399. 

  1399. 

    1400. 

  1400. 			// nouvel etat pour le footer

    1401. 

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

    1402. 

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

    1403. 

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

    1404. 

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

    1405. 

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

    1406. 

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

    1407. 

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

    1408. 

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

    1409. 

  1409. 

    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. 			// on en cr?? un sous HTML que l'on transforme en PDF

    1417. 

  1417. 			// pour r?cup?rer la hauteur

    1418. 

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

    1419. 

  1419. 			$sub = null;

    1420. 

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

    1421. 

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

    1422. 

  1422. 			$sub->MakeHTMLcode();

    1423. 

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

    1424. 

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

    1425. 

  1425. 

    1426. 

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

    1427. 

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

    1428. 

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

    1429. 

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

    1430. 

  1430. 			$this->setNewPositionForNewLine();

    1431. 

  1431. 

    1432. 

  1432. 			return true;

    1433. 

  1433. 		}

    1434. 

  1434. 

    1435. 

  1435. 		protected function c_PAGE_FOOTER_SUB($param)

    1436. 

  1436. 		{

    1437. 

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

    1438. 

  1438. 

    1439. 

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

    1440. 

  1440. 

    1441. 

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

    1442. 

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

    1443. 

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

    1444. 

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

    1445. 

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

    1446. 

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

    1447. 

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

    1448. 

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

    1449. 

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

    1450. 

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

    1451. 

  1451. 

    1452. 

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

    1453. 

  1453. 			$this->maxH = 0;

    1454. 

  1454. 

    1455. 

  1455. 			return true;

    1456. 

  1456. 		}

    1457. 

  1457. 

    1458. 

  1458. 		/**

    1459. 

  1459. 		* balise : NOBREAK

    1460. 

  1460. 		* mode : OUVERTURE

    1461. 

  1461. 		*

    1462. 

  1462. 		* @param	array	param?tres de l'?l?ment de parsing

    1463. 

  1463. 		* @return	null

    1464. 

  1464. 		*/

    1465. 

  1465. 		protected function o_NOBREAK($param)

    1466. 

  1466. 		{

    1467. 

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

    1468. 

  1468. 

    1469. 

  1469. 			$this->maxH = 0;

    1470. 

  1470. 

    1471. 

  1471. 			// on en cr?? un sous HTML que l'on transforme en PDF

    1472. 

  1472. 			// pour analyse les dimensions

    1473. 

  1473. 			// et voir si ca rentre

    1474. 

  1474. 			$sub = null;

    1475. 

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

    1476. 

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

    1477. 

  1477. 			$sub->MakeHTMLcode();

    1478. 

  1478. 

    1479. 

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

    1480. 

  1480. 			if (

    1481. 

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

    1482. 

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

    1483. 

  1483. 				)

    1484. 

  1484. 				$this->setNewPage();

    1485. 

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

    1486. 

  1486. 

    1487. 

  1487. 			return true;

    1488. 

  1488. 		}

    1489. 

  1489. 

    1490. 

  1490. 

    1491. 

  1491. 		/**

    1492. 

  1492. 		* balise : NOBREAK

    1493. 

  1493. 		* mode : FERMETURE

    1494. 

  1494. 		*

    1495. 

  1495. 		* @param	array	param?tres de l'?l?ment de parsing

    1496. 

  1496. 		* @return	null

    1497. 

  1497. 		*/

    1498. 

  1498. 		protected function c_NOBREAK($param)

    1499. 

  1499. 		{

    1500. 

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

    1501. 

  1501. 

    1502. 

  1502. 			$this->maxH = 0;

    1503. 

  1503. 

    1504. 

  1504. 			return true;

    1505. 

  1505. 		}

    1506. 

  1506. 

    1507. 

  1507. 		/**

    1508. 

  1508. 		* balise : DIV

    1509. 

  1509. 		* mode : OUVERTURE

    1510. 

  1510. 		*

    1511. 

  1511. 		* @param	array	param?tres de l'?l?ment de parsing

    1512. 

  1512. 		* @return	null

    1513. 

  1513. 		*/

    1514. 

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

    1515. 

  1515. 		{

    1516. 

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

    1517. 

  1517. 			if ($this->DEBUG_actif) $this->DEBUG_add('DIV', true);

    1518. 

  1518. 

    1519. 

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

    1520. 

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

    1521. 

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

    1522. 

  1522. 

    1523. 

  1523. 			$align_object = null;

    1524. 

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

    1525. 

  1525. 

    1526. 

  1526. 			$marge = array();

    1527. 

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

    1528. 

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

    1529. 

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

    1530. 

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

    1531. 

  1531. 

    1532. 

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

    1533. 

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

    1534. 

  1534. 

    1535. 

  1535. 			// on en cr?? un sous HTML que l'on transforme en PDF

    1536. 

  1536. 			// pour analyse les dimensions

    1537. 

  1537. 			$w = 0; $h = 0;

    1538. 

  1538. 			if (count($level))

    1539. 

  1539. 			{

    1540. 

  1540. 				$sub = null;

    1541. 

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

    1542. 

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

    1543. 

  1543. 				$sub->MakeHTMLcode();

    1544. 

  1544. 				$w = $sub->maxX;

    1545. 

  1545. 				$h = $sub->maxY;

    1546. 

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

    1547. 

  1547. 			}

    1548. 

  1548. 			$w_reel = $w;

    1549. 

  1549. 			$h_reel = $h;

    1550. 

  1550. 

    1551. 

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

    1552. 

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

    1553. 

  1553. 

    1554. 

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

    1555. 

  1555. 

    1556. 

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

    1557. 

  1557. 			{

    1558. 

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

    1559. 

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

    1560. 

  1560. 				$overflow = true;

    1561. 

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

    1562. 

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

    1563. 

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

    1564. 

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

    1565. 

  1565. 				$this->isInOverflow = true;

    1566. 

  1566. 			}

    1567. 

  1567. 			else

    1568. 

  1568. 			{

    1569. 

  1569. 				$over_w = null;

    1570. 

  1570. 				$over_h = null;

    1571. 

  1571. 				$overflow = false;

    1572. 

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

    1573. 

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

    1574. 

  1574. 			}

    1575. 

  1575. 

    1576. 

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

    1577. 

  1577. 			{

    1578. 

  1578. 				case 90:

    1579. 

  1579. 					$tmp = $over_h; $over_h = $over_w; $over_w = $tmp;

    1580. 

  1580. 					$tmp = $h_reel; $h_reel = $w_reel; $w_reel = $tmp;

    1581. 

  1581. 					unset($tmp);

    1582. 

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

    1583. 

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

    1584. 

  1584. 					$t_x =-$h;

    1585. 

  1585. 					$t_y = 0;

    1586. 

  1586. 					break;

    1587. 

  1587. 

    1588. 

  1588. 				case 180:

    1589. 

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

    1590. 

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

    1591. 

  1591. 					$t_x = -$w;

    1592. 

  1592. 					$t_y = -$h;

    1593. 

  1593. 					break;

    1594. 

  1594. 

    1595. 

  1595. 				case 270:

    1596. 

  1596. 					$tmp = $over_h; $over_h = $over_w; $over_w = $tmp;

    1597. 

  1597. 					$tmp = $h_reel; $h_reel = $w_reel; $w_reel = $tmp;

    1598. 

  1598. 					unset($t…
    1599.

Large files files are truncated, but you can click here to view the full file