PageRenderTime 61ms CodeModel.GetById 27ms RepoModel.GetById 1ms app.codeStats 0ms

/vendors/mpdf44/classes/svg.php

http://scp-soft.googlecode.com/
PHP | 1536 lines | 1178 code | 253 blank | 105 comment | 311 complexity | c967f7922067d633180f4a60ff35d2ae MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. <?php

    2. 

  2. //	svg class modified for mPDF by Ian Back: based on -

    3. 

  3. //	svg2pdf fpdf class

    4. 

  4. //	sylvain briand (syb@godisaduck.com), modified by rick trevino (rtrevino1@yahoo.com)

    5. 

  5. //	http://www.godisaduck.com/svg2pdf_with_fpdf

    6. 

  6. //	http://rhodopsin.blogspot.com

    7. 

  7. //	

    8. 

  8. //	cette class etendue est open source, toute modification devra cependant etre repertoriée~

    9. 

  9. 

    10. 

  10. 

    11. 

  11. 

    12. 

  12. class SVG {

    13. 

  13. 

    14. 

  14. 	var $svg_gradient;	//	array - contient les infos sur les gradient fill du svg classé par id du svg

    15. 

  15. 	var $svg_shadinglist;	//	array - contient les ids des objet shading

    16. 

  16. 	var $svg_info;		//	array contenant les infos du svg voulue par l'utilisateur

    17. 

  17. 	var $svg_attribs;		//	array - holds all attributes of root <svg> tag

    18. 

  18. 	var $svg_style;		//	array contenant les style de groupes du svg

    19. 

  19. 	var $svg_string;		//	String contenant le tracage du svg en lui m?me.

    20. 

  20. 	var $txt_data;		//    array - holds string info to write txt to image

    21. 

  21. 	var $txt_style;		// 	array - current text style

    22. 

  22. 	var $mpdf_ref;

    23. 

  23. 

    24. 

  24. 	function SVG(&$mpdf){

    25. 

  25. 		$this->svg_gradient = array();

    26. 

  26. 		$this->svg_shadinglist = array();

    27. 

  27. 		$this->txt_data = array();

    28. 

  28. 		$this->svg_string = '';

    29. 

  29. 		$this->svg_info = array();

    30. 

  30. 		$this->svg_attribs = array();

    31. 

  31. 

    32. 

  32. 		$this->mpdf_ref =& $mpdf;

    33. 

  33. 

    34. 

  34. 		$this->svg_style = array(

    35. 

  35. 			array(

    36. 

  36. 			'fill'		=> 'none',			//	pas de remplissage par defaut

    37. 

  37. 			'fill-opacity'	=> 1,				//	remplissage opaque par defaut

    38. 

  38. 			'fill-rule'		=> 'nonzero',		//	mode de remplissage par defaut

    39. 

  39. 			'stroke'		=> 'none',			//	pas de trait par defaut

    40. 

  40. 			'stroke-linecap'	=> 'butt',			//	style de langle par defaut

    41. 

  41. 			'stroke-linejoin'	=> 'miter',			//

    42. 

  42. 			'stroke-miterlimit' => 4,			//	limite de langle par defaut

    43. 

  43. 			'stroke-opacity'	=> 1,				//	trait opaque par defaut

    44. 

  44. 			'stroke-width'	=> 0				//	epaisseur du trait par defaut

    45. 

  45. 			)

    46. 

  46. 		);

    47. 

  47. 

    48. 

  48. 		$this->txt_style = array(

    49. 

  49. 			array(

    50. 

  50. 			'fill'		=> 'black',		//	pas de remplissage par defaut

    51. 

  51. 			'font-family' 	=> $mpdf->default_font,

    52. 

  52. 			'font-size'		=> $mpdf->default_font_size,		// 	****** this is pts

    53. 

  53. 			'font-weight'	=> 'normal',	//	normal | bold

    54. 

  54. 			'font-style'	=> 'normal',	//	italic | normal

    55. 

  55. 			'text-anchor'	=> 'start'		// alignment: start, middle, end

    56. 

  56. 			)

    57. 

  57. 		);

    58. 

  58. 

    59. 

  59. 

    60. 

  60. 

    61. 

  61. 	}

    62. 

  62. 

    63. 

  63. 	function svgGradient($gradient_info, $attribs, $element){

    64. 

  64. 

    65. 

  65. 		$n = count($this->mpdf_ref->gradients)+1;

    66. 

  66. 

    67. 

  67. 		// Get bounding dimensions of element

    68. 

  68. 		$w = 100;

    69. 

  69. 		$h = 100;

    70. 

  70. 		$x_offset = 0;

    71. 

  71. 		$y_offset = 0;

    72. 

  72. 		if ($element=='rect') {

    73. 

  73. 			$w = $attribs['width'];

    74. 

  74. 			$h = $attribs['height'];

    75. 

  75. 			$x_offset = $attribs['x'];

    76. 

  76. 			$y_offset = $attribs['y'];

    77. 

  77. 		}

    78. 

  78. 		else if ($element=='ellipse') {

    79. 

  79. 			$w = $attribs['rx']*2;

    80. 

  80. 			$h = $attribs['ry']*2;

    81. 

  81. 			$x_offset = $attribs['cx']-$attribs['rx'];

    82. 

  82. 			$y_offset = $attribs['cy']-$attribs['ry'];

    83. 

  83. 		}

    84. 

  84. 		else if ($element=='circle') {

    85. 

  85. 			$w = $attribs['r']*2;

    86. 

  86. 			$h = $attribs['r']*2;

    87. 

  87. 			$x_offset = $attribs['cx']-$attribs['r'];

    88. 

  88. 			$y_offset = $attribs['cy']-$attribs['r'];

    89. 

  89. 		}

    90. 

  90. 		else if ($element=='polygon') {

    91. 

  91. 			$pts = preg_split('/[ ,]+/', trim($attribs['points']));

    92. 

  92. 			$maxr=$maxb=0;

    93. 

  93. 			$minl=$mint=999999;

    94. 

  94. 			for ($i=0;$i<count($pts); $i++) {

    95. 

  95. 				if ($i % 2 == 0) {	// x values

    96. 

  96. 					$minl = min($minl,$pts[$i]);

    97. 

  97. 					$maxr = max($maxr,$pts[$i]);

    98. 

  98. 				}

    99. 

  99. 				else {	// y values

    100. 

  100. 					$mint = min($mint,$pts[$i]);

    101. 

  101. 					$maxb = max($maxb,$pts[$i]);

    102. 

  102. 				}

    103. 

  103. 			}

    104. 

  104. 			$w = $maxr-$minl;

    105. 

  105. 			$h = $maxb-$mint;

    106. 

  106. 			$x_offset = $minl;

    107. 

  107. 			$y_offset = $mint;

    108. 

  108. 		}

    109. 

  109. 		else if ($element=='path') {

    110. 

  110. 			preg_match_all('/([a-z]|[A-Z])([ ,\-.\d]+)*/', $attribs['d'], $commands, PREG_SET_ORDER);

    111. 

  111. 			$maxr=$maxb=0;

    112. 

  112. 			$minl=$mint=999999;

    113. 

  113. 			foreach($commands as $c){

    114. 

  114. 				if(count($c)==3){

    115. 

  115. 					list($tmp, $cmd, $arg) = $c;

    116. 

  116. 					if ($cmd=='M' || $cmd=='L' || $cmd=='C' || $cmd=='S' || $cmd=='Q' || $cmd=='T') {

    117. 

  117. 						$pts = preg_split('/[ ,]+/', trim($arg));

    118. 

  118. 						for ($i=0;$i<count($pts); $i++) {

    119. 

  119. 							if ($i % 2 == 0) {	// x values

    120. 

  120. 								$minl = min($minl,$pts[$i]);

    121. 

  121. 								$maxr = max($maxr,$pts[$i]);

    122. 

  122. 							}

    123. 

  123. 							else {	// y values

    124. 

  124. 								$mint = min($mint,$pts[$i]);

    125. 

  125. 								$maxb = max($maxb,$pts[$i]);

    126. 

  126. 							}

    127. 

  127. 						}

    128. 

  128. 					}

    129. 

  129. 					if ($cmd=='H') { // sets new x

    130. 

  130. 						$minl = min($minl,$arg);

    131. 

  131. 						$maxr = max($maxr,$arg);

    132. 

  132. 					}

    133. 

  133. 					if ($cmd=='V') { // sets new y

    134. 

  134. 						$mint = min($mint,$arg);

    135. 

  135. 						$maxb = max($maxb,$arg);

    136. 

  136. 					}

    137. 

  137. 				}

    138. 

  138. 			}

    139. 

  139. 			$w = $maxr-$minl;

    140. 

  140. 			$h = $maxb-$mint;

    141. 

  141. 			$x_offset = $minl;

    142. 

  142. 			$y_offset = $mint;

    143. 

  143. 		}

    144. 

  144. 		if (!$w) { $w = 100; }

    145. 

  145. 		if (!$h) { $h = 100; }

    146. 

  146. 		if ($x_offset==999999) { $x_offset = 0; }

    147. 

  147. 		if ($y_offset==999999) { $y_offset = 0; }

    148. 

  148. 

    149. 

  149. 

    150. 

  150. 		$return = "";

    151. 

  151. 		if ($gradient_info['type'] == 'linear'){

    152. 

  152. 			$this->mpdf_ref->gradients[$n]['type'] = 2;

    153. 

  153. 			if (isset($gradient_info['info']['x1'])) { $x1 = $gradient_info['info']['x1']; }

    154. 

  154. 			else { $x1 = 0; }

    155. 

  155. 			if (isset($gradient_info['info']['y1'])) { $y1 = $gradient_info['info']['y1']; }

    156. 

  156. 			else { $y1 = 0; }

    157. 

  157. 			if (isset($gradient_info['info']['x2'])) { $x2 = $gradient_info['info']['x2']; }

    158. 

  158. 			else { $x2 = 1; }

    159. 

  159. 			if (isset($gradient_info['info']['y2'])) { $y2 = $gradient_info['info']['y2']; }

    160. 

  160. 			else { $y2 = 0; }

    161. 

  161. 

    162. 

  162. 			if (stristr($x1, '%')!== false) { $x1 = ($x1+0)/100; }

    163. 

  163. 			if (stristr($x2, '%')!== false) { $x2 = ($x2+0)/100; }

    164. 

  164. 			if (stristr($y1, '%')!== false) { $y1 = ($y1+0)/100; }

    165. 

  165. 			if (stristr($y2, '%')!== false) { $y2 = ($y2+0)/100; }

    166. 

  166. 

    167. 

  167. 			$this->mpdf_ref->gradients[$n]['coords']=array($x1, $y1, $x2, $y2);

    168. 

  168. 

    169. 

  169. 			$a = $w;	// width

    170. 

  170. 			$b = 0;

    171. 

  171. 			$c = 0;

    172. 

  172. 			$d = -$h;	// height

    173. 

  173. 			$e = $x_offset;	// x- offset

    174. 

  174. 			$f = -$y_offset;	// -y-offset

    175. 

  175. 

    176. 

  176. 			$return .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f cm ', $a, $b, $c, $d, $e, $f);

    177. 

  177. 

    178. 

  178. 			$this->mpdf_ref->gradients[$n]['col1'] = $gradient_info['color'][0]['color'];

    179. 

  179. 			$this->mpdf_ref->gradients[$n]['col2'] = $gradient_info['color'][(count($gradient_info['color'])-1)]['color'];

    180. 

  180. 

    181. 

  181. 		}

    182. 

  182. 		else if ($gradient_info['type'] == 'radial'){

    183. 

  183. 

    184. 

  184. 			$this->mpdf_ref->gradients[$n]['type'] = 3;

    185. 

  185. 			$a = $w;	// width

    186. 

  186. 			$b = 0;

    187. 

  187. 			$c = 0;

    188. 

  188. 			$d = -$h;		// -height

    189. 

  189. 			$e = $x_offset;	// x- offset

    190. 

  190. 			$f = -$y_offset;	// -y-offset

    191. 

  191. 

    192. 

  192. 			$return .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f cm ', $a, $b, $c, $d, $e, $f);

    193. 

  193. 

    194. 

  194. 			if ($gradient_info['info']['x0'] || $gradient_info['info']['x0']===0) { $x0 = $gradient_info['info']['x0']; }

    195. 

  195. 			else { $x0 = 0.5; }

    196. 

  196. 			if ($gradient_info['info']['y0'] || $gradient_info['info']['y0']===0) { $y0 = $gradient_info['info']['y0']; }

    197. 

  197. 			else { $y0 = 0.5; }

    198. 

  198. 			if ($gradient_info['info']['r'] || $gradient_info['info']['r']===0) { $r = $gradient_info['info']['r']; }

    199. 

  199. 			else { $r = 0.5; }

    200. 

  200. 			if ($gradient_info['info']['x1'] || $gradient_info['info']['x1']===0) { $x1 = $gradient_info['info']['x1']; }

    201. 

  201. 			else { $x1 = $x0; }

    202. 

  202. 			if ($gradient_info['info']['y1'] || $gradient_info['info']['y1']===0) { $y1 = $gradient_info['info']['y1']; }

    203. 

  203. 			else { $y1 = $y0; }

    204. 

  204. 

    205. 

  205. 			if (stristr($x1, '%')!== false) { $x1 = ($x1+0)/100; }

    206. 

  206. 			if (stristr($x0, '%')!== false) { $x0 = ($x0+0)/100; }

    207. 

  207. 			if (stristr($y1, '%')!== false) { $y1 = ($y1+0)/100; }

    208. 

  208. 			if (stristr($y0, '%')!== false) { $y0 = ($y0+0)/100; }

    209. 

  209. 			if (stristr($r, '%')!== false) { $r = ($r+0)/100; }

    210. 

  210. 

    211. 

  211. 			// x1 and y1 (fx, fy) should be inside the circle defined by x0 y0 and r else error in mPDF

    212. 

  212. 			while (pow(($x1-$x0),2) + pow(($y1 - $y0),2) >= pow($r,2)) { $r += 0.05; }

    213. 

  213. 

    214. 

  214. 			$this->mpdf_ref->gradients[$n]['coords']=array( $x1, $y1, $x0, $y0, abs($r) );

    215. 

  215. 

    216. 

  216. 

    217. 

  217. 			$this->mpdf_ref->gradients[$n]['col1'] = $gradient_info['color'][0]['color'];

    218. 

  218. 			$this->mpdf_ref->gradients[$n]['col2'] = $gradient_info['color'][(count($gradient_info['color'])-1)]['color'];

    219. 

  219. 

    220. 

  220. 		}

    221. 

  221. 

    222. 

  222. 		$this->mpdf_ref->gradients[$n]['extend']=array('true','true');

    223. 

  223. 

    224. 

  224. /* Only uses 2 colours for mPDF

    225. 

  225. 		$this->mpdf_ref->gradients[$n]['color'] = array();

    226. 

  226. 		$n_color = count($gradient_info['color']);

    227. 

  227. 		for ($i = 0;$i<$n_color;$i++){

    228. 

  228. 			$color = array (

    229. 

  229. 				'color' => $gradient_info['color'][$i]['color'],

    230. 

  230. 				'offset' => $gradient_info['color'][$i]['offset'],

    231. 

  231. 				'opacity' => $gradient_info['color'][$i]['opacity']

    232. 

  232. 			);

    233. 

  233. 			array_push($this->mpdf_ref->gradients[$n]['color'],$color);

    234. 

  234. 		}

    235. 

  235. */

    236. 

  236. 

    237. 

  237. 		$return .= '/Sh'.count($this->mpdf_ref->gradients).' sh Q ';

    238. 

  238. 		return $return;

    239. 

  239. 

    240. 

  240. 	}

    241. 

  241. 

    242. 

  242. 	function svgOffset ($attribs){

    243. 

  243. 		// save all <svg> tag attributes

    244. 

  244. 		$this->svg_attribs = $attribs;

    245. 

  245. 		if(isset($this->svg_attribs['viewBox'])) {

    246. 

  246. 			$vb = preg_split('/\s+/is', trim($this->svg_attribs['viewBox']));

    247. 

  247. 			if (count($vb)==4) {

    248. 

  248. 				$this->svg_info['x'] = $vb[0];

    249. 

  249. 				$this->svg_info['y'] = $vb[1];

    250. 

  250. 				$this->svg_info['w'] = $vb[2];

    251. 

  251. 				$this->svg_info['h'] = $vb[3];

    252. 

  252. 				return;

    253. 

  253. 			}

    254. 

  254. 		}

    255. 

  255. 

    256. 

  256. 		$svg_w = $this->mpdf_ref->ConvertSize($attribs['width']);	// mm (interprets numbers as pixels)

    257. 

  257. 		$svg_h = $this->mpdf_ref->ConvertSize($attribs['height']);	// mm

    258. 

  258. 

    259. 

  259. 		// Added to handle file without height or width specified

    260. 

  260. 		if (!$svg_w && !$svg_h) { $svg_w = $svg_h = $this->mpdf_ref->blk[$this->mpdf_ref->blklvl]['inner_width'] ; }	// DEFAULT

    261. 

  261. 		if (!$svg_w) { $svg_w = $svg_h; }

    262. 

  262. 		if (!$svg_h) { $svg_h = $svg_w; }

    263. 

  263. 

    264. 

  264. 		$this->svg_info['x'] = 0;

    265. 

  265. 		$this->svg_info['y'] = 0;

    266. 

  266. 		$this->svg_info['w'] = $svg_w/0.2645;	// mm->pixels

    267. 

  267. 		$this->svg_info['h'] = $svg_h/0.2645;	// mm->pixels

    268. 

  268. 	}

    269. 

  269. 

    270. 

  270. 

    271. 

  271. 	//

    272. 

  272. 	// check if points are within svg, if not, set to max

    273. 

  273. 	function svg_overflow($x,$y)

    274. 

  274. 	{

    275. 

  275. 		$x2 = $x;

    276. 

  276. 		$y2 = $y;

    277. 

  277. 		if(isset($this->svg_attribs['overflow']))

    278. 

  278. 		{

    279. 

  279. 			if($this->svg_attribs['overflow'] == 'hidden')

    280. 

  280. 			{

    281. 

  281. 				// Not sure if this is supposed to strip off units, but since I dont use any I will omlt this step

    282. 

  282. 				$svg_w = preg_replace("/([0-9\.]*)(.*)/i","$1",$this->svg_attribs['width']);

    283. 

  283. 				$svg_h = preg_replace("/([0-9\.]*)(.*)/i","$1",$this->svg_attribs['height']);

    284. 

  284. 				

    285. 

  285. 				// $xmax = floor($this->svg_attribs['width']);

    286. 

  286. 				$xmax = floor($svg_w);

    287. 

  287. 				$xmin = 0;

    288. 

  288. 				// $ymax = floor(($this->svg_attribs['height'] * -1));

    289. 

  289. 				$ymax = floor(($svg_h * -1));

    290. 

  290. 				$ymin = 0;

    291. 

  291. 

    292. 

  292. 				if($x > $xmax) $x2 = $xmax; // right edge

    293. 

  293. 				if($x < $xmin) $x2 = $xmin; // left edge

    294. 

  294. 				if($y < $ymax) $y2 = $ymax; // bottom 

    295. 

  295. 				if($y > $ymin) $y2 = $ymin; // top 

    296. 

  296. 

    297. 

  297. 			}

    298. 

  298. 		}

    299. 

  299. 

    300. 

  300. 

    301. 

  301. 		return array( 'x' => $x2, 'y' => $y2);

    302. 

  302. 	}

    303. 

  303. 

    304. 

  304. 

    305. 

  305. 

    306. 

  306. 	function svgDefineStyle($critere_style){

    307. 

  307. 

    308. 

  308. 		$tmp = count($this->svg_style)-1;

    309. 

  309. 		$current_style = $this->svg_style[$tmp];

    310. 

  310. 

    311. 

  311. 		unset($current_style['transformations']);

    312. 

  312. 

    313. 

  313. 		// TRANSFORM SCALE

    314. 

  314. 		$transformations = '';

    315. 

  315. 		if (isset($critere_style['transform'])){

    316. 

  316. 			preg_match_all('/(matrix|translate|scale|rotate|skewX|skewY)\((.*?)\)/is',$critere_style['transform'],$m);

    317. 

  317. 			if (count($m[0])) {

    318. 

  318. 				for($i=0; $i<count($m[0]); $i++) {

    319. 

  319. 					$c = strtolower($m[1][$i]);

    320. 

  320. 					$v = trim($m[2][$i]);

    321. 

  321. 					$vv = preg_split('/[ ,]+/',$v);

    322. 

  322. 					if ($c=='matrix' && count($vv)==6) {

    323. 

  323. 						$transformations .= sprintf(' %.3f %.3f %.3f %.3f %.3f %.3f cm ', $vv[0], $vv[1], $vv[2], $vv[3], $vv[4], $vv[5]);

    324. 

  324. 					}

    325. 

  325. 					else if ($c=='translate' && count($vv)) {

    326. 

  326. 						$tm[4] = $vv[0];

    327. 

  327. 						if (count($vv)==2) { $t_y = -$vv[1]; }

    328. 

  328. 						else { $t_y = 0; }

    329. 

  329. 						$tm[5] = $t_y;

    330. 

  330. 						$transformations .= sprintf(' 1 0 0 1 %.3f %.3f cm ', $tm[4], $tm[5]);

    331. 

  331. 					}

    332. 

  332. 					else if ($c=='scale' && count($vv)) {

    333. 

  333. 						if (count($vv)==2) { $s_y = $vv[1]; }

    334. 

  334. 						else { $s_y = $vv[0]; }

    335. 

  335. 						$tm[0] = $vv[0];

    336. 

  336. 						$tm[3] = $s_y;

    337. 

  337. 						$transformations .= sprintf(' %.3f 0 0 %.3f 0 0 cm ', $tm[0], $tm[3]);

    338. 

  338. 					}

    339. 

  339. 					else if ($c=='rotate' && count($vv)) {

    340. 

  340. 						$tm[0] = cos(deg2rad(-$vv[0]));

    341. 

  341. 						$tm[1] = sin(deg2rad(-$vv[0]));

    342. 

  342. 						$tm[2] = -$tm[1];

    343. 

  343. 						$tm[3] = $tm[0];

    344. 

  344. 						if (count($vv)==3) {

    345. 

  345. 							$transformations .= sprintf(' 1 0 0 1 %.3f %.3f cm ', $vv[1], -$vv[2]);

    346. 

  346. 						}

    347. 

  347. 						$transformations .= sprintf(' %.3f %.3f %.3f %.3f 0 0 cm ', $tm[0], $tm[1], $tm[2], $tm[3]);

    348. 

  348. 						if (count($vv)==3) {

    349. 

  349. 							$transformations .= sprintf(' 1 0 0 1 %.3f %.3f cm ', -$vv[1], $vv[2]);

    350. 

  350. 						}

    351. 

  351. 					}

    352. 

  352. 					else if ($c=='skewx' && count($vv)) {

    353. 

  353. 						$tm[2] = tan(deg2rad(-$vv[0]));

    354. 

  354. 						$transformations .= sprintf(' 1 0 %.3f 1 0 0 cm ', $tm[2]);

    355. 

  355. 					}

    356. 

  356. 					else if ($c=='skewy' && count($vv)) {

    357. 

  357. 						$tm[1] = tan(deg2rad(-$vv[0]));

    358. 

  358. 						$transformations .= sprintf(' 1 %.3f 0 1 0 0 cm ', $tm[1]);

    359. 

  359. 					}

    360. 

  360. 

    361. 

  361. 				}

    362. 

  362. 			}

    363. 

  363. 			$current_style['transformations'] = $transformations;

    364. 

  364. 		}

    365. 

  365. 

    366. 

  366. 		if (isset($critere_style['style'])){

    367. 

  367. 			if (preg_match('/fill:\s*rgb\((\d+),\s*(\d+),\s*(\d+)\)/',$critere_style['style'], $m)) {

    368. 

  368. 				$current_style['fill'] = '#'.str_pad(dechex($m[1]), 2, "0", STR_PAD_LEFT).str_pad(dechex($m[2]), 2, "0", STR_PAD_LEFT).str_pad(dechex($m[3]), 2, "0", STR_PAD_LEFT);

    369. 

  369. 			}

    370. 

  370. 			else { $tmp = preg_replace("/(.*)fill:\s*([a-z0-9#]*|none)(.*)/i","$2",$critere_style['style']);

    371. 

  371. 				if ($tmp != $critere_style['style']){ $current_style['fill'] = $tmp; }

    372. 

  372. 			}

    373. 

  373. 

    374. 

  374. 			$tmp = preg_replace("/(.*)fill-opacity:\s*([a-z0-9.]*|none)(.*)/i","$2",$critere_style['style']);

    375. 

  375. 			if ($tmp != $critere_style['style']){ $current_style['fill-opacity'] = $tmp;}

    376. 

  376. 

    377. 

  377. 			$tmp = preg_replace("/(.*)fill-rule:\s*([a-z0-9#]*|none)(.*)/i","$2",$critere_style['style']);

    378. 

  378. 			if ($tmp != $critere_style['style']){ $current_style['fill-rule'] = $tmp;}

    379. 

  379. 

    380. 

  380. 			if (preg_match('/stroke:\s*rgb\((\d+),\s*(\d+),\s*(\d+)\)/',$critere_style['style'], $m)) {

    381. 

  381. 				$current_style['stroke'] = '#'.str_pad(dechex($m[1]), 2, "0", STR_PAD_LEFT).str_pad(dechex($m[2]), 2, "0", STR_PAD_LEFT).str_pad(dechex($m[3]), 2, "0", STR_PAD_LEFT);

    382. 

  382. 			}

    383. 

  383. 			else { $tmp = preg_replace("/(.*)stroke:\s*([a-z0-9#]*|none)(.*)/i","$2",$critere_style['style']);

    384. 

  384. 				if ($tmp != $critere_style['style']){ $current_style['stroke'] = $tmp; }

    385. 

  385. 			}

    386. 

  386. 			

    387. 

  387. 			$tmp = preg_replace("/(.*)stroke-linecap:\s*([a-z0-9#]*|none)(.*)/i","$2",$critere_style['style']);

    388. 

  388. 			if ($tmp != $critere_style['style']){ $current_style['stroke-linecap'] = $tmp;}

    389. 

  389. 

    390. 

  390. 			$tmp = preg_replace("/(.*)stroke-linejoin:\s*([a-z0-9#]*|none)(.*)/i","$2",$critere_style['style']);

    391. 

  391. 			if ($tmp != $critere_style['style']){ $current_style['stroke-linejoin'] = $tmp;}

    392. 

  392. 			

    393. 

  393. 			$tmp = preg_replace("/(.*)stroke-miterlimit:\s*([a-z0-9#]*|none)(.*)/i","$2",$critere_style['style']);

    394. 

  394. 			if ($tmp != $critere_style['style']){ $current_style['stroke-miterlimit'] = $tmp;}

    395. 

  395. 			

    396. 

  396. 			$tmp = preg_replace("/(.*)stroke-opacity:\s*([a-z0-9.]*|none)(.*)/i","$2",$critere_style['style']);

    397. 

  397. 			if ($tmp != $critere_style['style']){ $current_style['stroke-opacity'] = $tmp; }

    398. 

  398. 			

    399. 

  399. 			$tmp = preg_replace("/(.*)stroke-width:\s*([a-z0-9.]*|none)(.*)/i","$2",$critere_style['style']);

    400. 

  400. 			if ($tmp != $critere_style['style']){ $current_style['stroke-width'] = $tmp;}

    401. 

  401. 

    402. 

  402. 		}

    403. 

  403. 

    404. 

  404. 		if(isset($critere_style['fill'])){

    405. 

  405. 			$current_style['fill'] = $critere_style['fill'];

    406. 

  406. 		}

    407. 

  407. 

    408. 

  408. 		if(isset($critere_style['fill-opacity'])){

    409. 

  409. 			$current_style['fill-opacity'] = $critere_style['fill-opacity'];

    410. 

  410. 		}

    411. 

  411. 

    412. 

  412. 		if(isset($critere_style['fill-rule'])){

    413. 

  413. 			$current_style['fill-rule'] = $critere_style['fill-rule'];

    414. 

  414. 		}

    415. 

  415. 

    416. 

  416. 		if(isset($critere_style['stroke'])){

    417. 

  417. 			$current_style['stroke'] = $critere_style['stroke'];

    418. 

  418. 		}

    419. 

  419. 

    420. 

  420. 		if(isset($critere_style['stroke-linecap'])){

    421. 

  421. 			$current_style['stroke-linecap'] = $critere_style['stroke-linecap'];

    422. 

  422. 		}

    423. 

  423. 

    424. 

  424. 		if(isset($critere_style['stroke-linejoin'])){

    425. 

  425. 			$current_style['stroke-linejoin'] = $critere_style['stroke-linejoin'];

    426. 

  426. 		}

    427. 

  427. 

    428. 

  428. 		if(isset($critere_style['stroke-miterlimit'])){

    429. 

  429. 			$current_style['stroke-miterlimit'] = $critere_style['stroke-miterlimit'];

    430. 

  430. 		}

    431. 

  431. 

    432. 

  432. 		if(isset($critere_style['stroke-opacity'])){

    433. 

  433. 			$current_style['stroke-opacity'] = $critere_style['stroke-opacity'];

    434. 

  434. 		}

    435. 

  435. 

    436. 

  436. 		if(isset($critere_style['stroke-width'])){

    437. 

  437. 			$current_style['stroke-width'] = $critere_style['stroke-width'];

    438. 

  438. 		}

    439. 

  439. 

    440. 

  440. 		return $current_style;

    441. 

  441. 

    442. 

  442. 	}

    443. 

  443. 

    444. 

  444. 	//

    445. 

  445. 	//	Cette fonction ecrit le style dans le stream svg.

    446. 

  446. 	function svgStyle($critere_style, $attribs, $element){

    447. 

  447. 		$path_style = '';

    448. 

  448. 

    449. 

  449. 		if (substr_count($critere_style['fill'],'url')>0){

    450. 

  450. 			//

    451. 

  451. 			// couleur degradé

    452. 

  452. 			$id_gradient = preg_replace("/url\(#([\w_]*)\)/i","$1",$critere_style['fill']);

    453. 

  453. 			if ($id_gradient != $critere_style['fill']) {

    454. 

  454. 				$fill_gradient = $this->svgGradient($this->svg_gradient[$id_gradient], $attribs, $element);

    455. 

  455. 

    456. 

  456. 				$path_style = "q ";

    457. 

  457. 				$w = "W";

    458. 

  458. 				$style .= 'N';

    459. 

  459. 			}

    460. 

  460. 

    461. 

  461. 		}

    462. 

  462. 		else if ($critere_style['fill'] != 'none'){

    463. 

  463. 			//	fill couleur pleine

    464. 

  464. 			$col = $this->mpdf_ref->ConvertColor($critere_style['fill']);

    465. 

  465. 			if ($col) {

    466. 

  466. 				$path_style .= sprintf('%.3f %.3f %.3f rg ',$col['R']/255,$col['G']/255,$col['B']/255);

    467. 

  467. 				$style .= 'F';

    468. 

  468. 			}

    469. 

  469. 		}

    470. 

  470. 

    471. 

  471. 		if ($critere_style['stroke'] != 'none'){

    472. 

  472. 			$col = $this->mpdf_ref->ConvertColor($critere_style['stroke']);

    473. 

  473. 			if ($col) {

    474. 

  474. 				$path_style .= sprintf('%.3f %.3f %.3f RG ',$col['R']/255,$col['G']/255,$col['B']/255);

    475. 

  475. 				$style .= 'D';

    476. 

  476. 

    477. 

  477. 				$path_style .= sprintf('%.3f w ',$critere_style['stroke-width']);

    478. 

  478. 			}

    479. 

  479. 		}

    480. 

  480. 

    481. 

  481. 

    482. 

  482. 	if ($critere_style['stroke'] != 'none'){

    483. 

  483. 		if ($critere_style['stroke-linejoin'] == 'miter'){

    484. 

  484. 			$path_style .= ' 0 j ';

    485. 

  485. 		}

    486. 

  486. 		else if ($critere_style['stroke-linejoin'] == 'round'){

    487. 

  487. 			$path_style .= ' 1 j ';

    488. 

  488. 		}

    489. 

  489. 		else if ($critere_style['stroke-linejoin'] == 'bevel'){

    490. 

  490. 			$path_style .= ' 2 j ';

    491. 

  491. 		}

    492. 

  492. 

    493. 

  493. 		if ($critere_style['stroke-linecap'] == 'butt'){

    494. 

  494. 			$path_style .= ' 0 J ';

    495. 

  495. 		}

    496. 

  496. 		else if ($critere_style['stroke-linecap'] == 'round'){

    497. 

  497. 			$path_style .= ' 1 J ';

    498. 

  498. 		}

    499. 

  499. 		else if ($critere_style['stroke-linecap'] == 'square'){

    500. 

  500. 			$path_style .= ' 2 J ';

    501. 

  501. 		}

    502. 

  502. 

    503. 

  503. 		if (isset($critere_style['stroke-miterlimit'])){

    504. 

  504. 			$path_style .= sprintf('%.2f M ',$critere_style['stroke-miterlimit']);

    505. 

  505. 		}

    506. 

  506. 	}

    507. 

  507. 

    508. 

  508. 

    509. 

  509. 		if ($critere_style['fill-opacity'] > 0 && $critere_style['fill-opacity'] <= 1){

    510. 

  510. 			$gs = $this->mpdf_ref->AddExtGState(array('ca'=>$critere_style['fill-opacity'], 'BM'=>'/Normal'));

    511. 

  511. 			$path_style .= sprintf(' /GS%d gs ', $gs);

    512. 

  512. 		}

    513. 

  513. 

    514. 

  514. 		if ($critere_style['stroke-opacity'] > 0 && $critere_style['stroke-opacity'] <= 1){ 

    515. 

  515. 			$gs = $this->mpdf_ref->AddExtGState(array('CA'=>$critere_style['stroke-opacity'], 'BM'=>'/Normal'));

    516. 

  516. 			$path_style .= sprintf(' /GS%d gs ', $gs);

    517. 

  517. 		}

    518. 

  518. 

    519. 

  519. 		switch ($style){

    520. 

  520. 			case 'F':

    521. 

  521. 				$op = 'f';

    522. 

  522. 			break;

    523. 

  523. 			case 'FD':

    524. 

  524. 				$op = 'B';

    525. 

  525. 			break;

    526. 

  526. 			case 'ND':

    527. 

  527. 				$op = 'S';

    528. 

  528. 			break;

    529. 

  529. 			case 'D':

    530. 

  530. 				$op = 'S';

    531. 

  531. 			break;

    532. 

  532. 			default:

    533. 

  533. 				$op = 'n';

    534. 

  534. 		}

    535. 

  535. 

    536. 

  536. 		$final_style = "$path_style $w $op $fill_gradient \n";

    537. 

  537. 		// echo 'svgStyle: '. $final_style .'<br><br>';

    538. 

  538. 

    539. 

  539. 		return $final_style;

    540. 

  540. 

    541. 

  541. 	}

    542. 

  542. 

    543. 

  543. 	//

    544. 

  544. 	//	fonction retracant les <path />

    545. 

  545. 	function svgPath($command, $arguments){

    546. 

  546. 

    547. 

  547. 		global $xbase, $ybase;

    548. 

  548. 

    549. 

  549. 		$path_cmd = '';

    550. 

  550. 

    551. 

  551. 

    552. 

  552. 		preg_match_all('/[\-^]?[\d.]+/', $arguments, $a, PREG_SET_ORDER);

    553. 

  553. 

    554. 

  554. 

    555. 

  555. 		//	if the command is a capital letter, the coords go absolute, otherwise relative

    556. 

  556. 		if(strtolower($command) == $command) $relative = true;

    557. 

  557. 		else $relative = false;

    558. 

  558. 

    559. 

  559. 

    560. 

  560. 		$ile_argumentow = count($a);

    561. 

  561. 

    562. 

  562. 		//	each command may have different needs for arguments [1 to 8]

    563. 

  563. 

    564. 

  564. 		switch(strtolower($command)){

    565. 

  565. 			case 'm': // move

    566. 

  566. 				for($i = 0; $i<$ile_argumentow; $i+=2){

    567. 

  567. 					$x = $a[$i][0]; 

    568. 

  568. 					$y = $a[$i+1][0]; 

    569. 

  569. 					if($relative){

    570. 

  570. 						$pdfx = ($xbase + $x);

    571. 

  571. 						$pdfy = ($ybase - $y);

    572. 

  572. 						$xbase += $x;

    573. 

  573. 						$ybase += -$y;

    574. 

  574. 					}

    575. 

  575. 					else{

    576. 

  576. 						$pdfx = $x;

    577. 

  577. 						$pdfy =  -$y ;

    578. 

  578. 						$xbase = $x;

    579. 

  579. 						$ybase = -$y;

    580. 

  580. 					}

    581. 

  581. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    582. 

  582. 					if($i == 0) $path_cmd .= sprintf('%.3f %.3f m ', $pdf_pt['x'], $pdf_pt['y']);

    583. 

  583. 					else $path_cmd .= sprintf('%.3f %.3f l ',  $pdf_pt['x'], $pdf_pt['y']);

    584. 

  584. 				}

    585. 

  585. 			break;

    586. 

  586. 			case 'l': // a simple line

    587. 

  587. 				for($i = 0; $i<$ile_argumentow; $i+=2){

    588. 

  588. 					$x = ($a[$i][0]); 

    589. 

  589. 					$y = ($a[$i+1][0]); 

    590. 

  590. 					if($relative){

    591. 

  591. 						$pdfx = ($xbase + $x);

    592. 

  592. 						$pdfy = ($ybase - $y);

    593. 

  593. 						$xbase += $x;

    594. 

  594. 						$ybase += -$y;

    595. 

  595. 					}

    596. 

  596. 					else{

    597. 

  597. 						$pdfx = $x ;

    598. 

  598. 						$pdfy =  -$y ;

    599. 

  599. 						$xbase = $x;

    600. 

  600. 						$ybase = -$y;

    601. 

  601. 					}

    602. 

  602. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    603. 

  603. 					$path_cmd .= sprintf('%.3f %.3f l ',  $pdf_pt['x'], $pdf_pt['y']);

    604. 

  604. 				}

    605. 

  605. 			break;

    606. 

  606. 			case 'h': // a very simple horizontal line

    607. 

  607. 				for($i = 0; $i<$ile_argumentow; $i++){

    608. 

  608. 					$x = ($a[$i][0]); 

    609. 

  609. 					if($relative){

    610. 

  610. 						$y = 0;

    611. 

  611. 						$pdfx = ($xbase + $x) ;

    612. 

  612. 						$pdfy = ($ybase - $y) ;

    613. 

  613. 						$xbase += $x;

    614. 

  614. 						$ybase += -$y;

    615. 

  615. 					}

    616. 

  616. 					else{

    617. 

  617. 						$y = -$ybase;

    618. 

  618. 						$pdfx = $x;

    619. 

  619. 						$pdfy =  -$y;

    620. 

  620. 						$xbase = $x;

    621. 

  621. 						$ybase = -$y;

    622. 

  622. 					}

    623. 

  623. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    624. 

  624. 					$path_cmd .= sprintf('%.3f %.3f l ', $pdf_pt['x'], $pdf_pt['y']);

    625. 

  625. 				}

    626. 

  626. 			break;

    627. 

  627. 			case 'v': // the simplest line, vertical

    628. 

  628. 				for($i = 0; $i<$ile_argumentow; $i++){

    629. 

  629. 					$y = ($a[$i][0]); 

    630. 

  630. 					if($relative){

    631. 

  631. 						$x = 0;

    632. 

  632. 						$pdfx = ($xbase + $x);

    633. 

  633. 						$pdfy = ($ybase - $y);

    634. 

  634. 						$xbase += $x;

    635. 

  635. 						$ybase += -$y;

    636. 

  636. 					}

    637. 

  637. 					else{

    638. 

  638. 						$x = $xbase;

    639. 

  639. 						$pdfx = $x;

    640. 

  640. 						$pdfy =  -$y;

    641. 

  641. 						$xbase = $x;

    642. 

  642. 						$ybase = -$y;

    643. 

  643. 					}

    644. 

  644. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    645. 

  645. 					$path_cmd .= sprintf('%.3f %.3f l ', $pdf_pt['x'], $pdf_pt['y']);

    646. 

  646. 				}

    647. 

  647. 			break;

    648. 

  648. 			case 's': // bezier with first vertex equal first control

    649. 

  649. 			   if ($this->lastcommand == 'C' || $this->lastcommand == 'c') {

    650. 

  650. 

    651. 

  651. 				for($i = 0; $i<$ile_argumentow; $i += 4){

    652. 

  652. 					$x1 = $this->lastcontrolpoints[0];

    653. 

  653. 					$y1 = $this->lastcontrolpoints[1];

    654. 

  654. 					$x2 = ($a[$i][0]); 

    655. 

  655. 					$y2 = ($a[$i+1][0]); 

    656. 

  656. 					$x = ($a[$i+2][0]); 

    657. 

  657. 					$y = ($a[$i+3][0]); 

    658. 

  658. 					if($relative){

    659. 

  659. 						$pdfx1 = ($xbase + $x1);

    660. 

  660. 						$pdfy1 = ($ybase - $y1);

    661. 

  661. 						$pdfx2 = ($xbase + $x2);

    662. 

  662. 						$pdfy2 = ($ybase - $y2);

    663. 

  663. 						$pdfx = ($xbase + $x);

    664. 

  664. 						$pdfy = ($ybase - $y);

    665. 

  665. 						$xbase += $x;

    666. 

  666. 						$ybase += -$y;

    667. 

  667. 					}

    668. 

  668. 					else{

    669. 

  669. 						$pdfx1 = $xbase + $x1;

    670. 

  670. 						$pdfy1 = $ybase -$y1;

    671. 

  671. 						$pdfx2 = $x2;

    672. 

  672. 						$pdfy2 = -$y2;

    673. 

  673. 						$pdfx = $x;

    674. 

  674. 						$pdfy =  -$y;

    675. 

  675. 						$xbase = $x;

    676. 

  676. 						$ybase = -$y;

    677. 

  677. 					}

    678. 

  678. 					$this->lastcontrolpoints = array(($x-$x1),($y-$y1));

    679. 

  679. 					// $pdf_pt2 = $this->svg_overflow($pdfx2,$pdfy2);

    680. 

  680. 					// $pdf_pt1 = $this->svg_overflow($pdfx1,$pdfy1);

    681. 

  681. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    682. 

  682. 					if( ($pdf_pt['x'] != $pdfx) || ($pdf_pt['y'] != $pdfy) )

    683. 

  683. 					{

    684. 

  684. 						$path_cmd .= sprintf('%.3f %.3f l ',  $pdf_pt['x'], $pdf_pt['y']);

    685. 

  685. 					}

    686. 

  686. 					else

    687. 

  687. 					{

    688. 

  688. 						$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $pdfx1, $pdfy1, $pdfx2, $pdfy2, $pdfx, $pdfy);

    689. 

  689. 					}

    690. 

  690. 

    691. 

  691. 				}

    692. 

  692. 			   }

    693. 

  693. 			break;

    694. 

  694. 			case 'c': // bezier with second vertex equal second control

    695. 

  695. 			for($i = 0; $i<$ile_argumentow; $i += 6){

    696. 

  696. 					$x1 = ($a[$i][0]); 

    697. 

  697. 					$y1 = ($a[$i+1][0]); 

    698. 

  698. 					$x2 = ($a[$i+2][0]); 

    699. 

  699. 					$y2 = ($a[$i+3][0]); 

    700. 

  700. 					$x = ($a[$i+4][0]); 

    701. 

  701. 					$y = ($a[$i+5][0]); 

    702. 

  702. 					if($relative){

    703. 

  703. 						$pdfx1 = ($xbase + $x1);

    704. 

  704. 						$pdfy1 = ($ybase - $y1);

    705. 

  705. 						$pdfx2 = ($xbase + $x2);

    706. 

  706. 						$pdfy2 = ($ybase - $y2);

    707. 

  707. 						$pdfx = ($xbase + $x);

    708. 

  708. 						$pdfy = ($ybase - $y);

    709. 

  709. 						$xbase += $x;

    710. 

  710. 						$ybase += -$y;

    711. 

  711. 					}

    712. 

  712. 					else{

    713. 

  713. 						$pdfx1 = $x1;

    714. 

  714. 						$pdfy1 = -$y1;

    715. 

  715. 						$pdfx2 = $x2;

    716. 

  716. 						$pdfy2 = -$y2;

    717. 

  717. 						$pdfx = $x;

    718. 

  718. 						$pdfy =  -$y;

    719. 

  719. 						$xbase = $x;

    720. 

  720. 						$ybase = -$y;

    721. 

  721. 					}

    722. 

  722. 					$this->lastcontrolpoints = array(($x-$x2),($y-$y2));

    723. 

  723. 					// $pdf_pt2 = $this->svg_overflow($pdfx2,$pdfy2);

    724. 

  724. 					// $pdf_pt1 = $this->svg_overflow($pdfx1,$pdfy1);

    725. 

  725. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    726. 

  726. 					if( ($pdf_pt['x'] != $pdfx) || ($pdf_pt['y'] != $pdfy) )

    727. 

  727. 					{

    728. 

  728. 						$path_cmd .= sprintf('%.3f %.3f l ',  $pdf_pt['x'], $pdf_pt['y']);

    729. 

  729. 					}

    730. 

  730. 					else

    731. 

  731. 					{

    732. 

  732. 						$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $pdfx1, $pdfy1, $pdfx2, $pdfy2, $pdfx, $pdfy);

    733. 

  733. 					}

    734. 

  734. 

    735. 

  735. 				}

    736. 

  736. 			break;

    737. 

  737. 

    738. 

  738. 			case 'q': // bezier quadratic avec point de control

    739. 

  739. 				for($i = 0; $i<$ile_argumentow; $i += 4){

    740. 

  740. 					$x1 = ($a[$i][0]); 

    741. 

  741. 					$y1 = ($a[$i+1][0]); 

    742. 

  742. 					$x = ($a[$i+2][0]); 

    743. 

  743. 					$y = ($a[$i+3][0]); 

    744. 

  744. 					if($relative){

    745. 

  745. 

    746. 

  746. 						$pdfx1 = ($xbase + ($x1*2/3));

    747. 

  747. 						$pdfy1 = ($ybase - ($y1*2/3));

    748. 

  748. 

    749. 

  749. 						$pdfx2 = ($xbase + $x - ($x1*2/3));

    750. 

  750. 						$pdfy2 = ($ybase - $y - ($y1*2/3));

    751. 

  751. 

    752. 

  752. 						$pdfx = ($xbase + $x);

    753. 

  753. 						$pdfy = ($ybase - $y);

    754. 

  754. 						$xbase += $x;

    755. 

  755. 						$ybase += -$y;

    756. 

  756. 					}

    757. 

  757. 					else{

    758. 

  758. 						$pdfx1 = ($xbase+(($x1-$xbase)*2/3));

    759. 

  759. 						$pdfy1 = ($ybase-(($y1+$ybase)*2/3));

    760. 

  760. 

    761. 

  761. 						$pdfx2 = ($x+(($x1-$x)*2/3));

    762. 

  762. 						$pdfy2 = (-$y-(($y1-$y)*2/3));

    763. 

  763. 

    764. 

  764. 						$pdfx = $x;

    765. 

  765. 						$pdfy =  -$y;

    766. 

  766. 						$xbase = $x;

    767. 

  767. 						$ybase = -$y;

    768. 

  768. 					}

    769. 

  769. 					$this->lastcontrolpoints = array(($x-$x1),($y-$y1));

    770. 

  770. 

    771. 

  771. 					// $pdf_pt2 = $this->svg_overflow($pdfx2,$pdfy2);

    772. 

  772. 					// $pdf_pt1 = $this->svg_overflow($pdfx1,$pdfy1);

    773. 

  773. 					$pdf_pt = $this->svg_overflow($pdfx,$pdfy);

    774. 

  774. 					if( ($pdf_pt['x'] != $pdfx) || ($pdf_pt['y'] != $pdfy) )

    775. 

  775. 					{

    776. 

  776. 						$path_cmd .= sprintf('%.3f %.3f l ',  $pdf_pt['x'], $pdf_pt['y']);

    777. 

  777. 					}

    778. 

  778. 					else

    779. 

  779. 					{

    780. 

  780. 						$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $pdfx1, $pdfy1, $pdfx2, $pdfy2, $pdfx, $pdfy);

    781. 

  781. 					}

    782. 

  782. 				}

    783. 

  783. 			break;

    784. 

  784. 			case 't': // bezier quadratic avec point de control simetrique a lancien point de control

    785. 

  785. 				if ($this->lastcommand == 'Q' || $this->lastcommand == 'q' || $this->lastcommand == 'T' || $this->lastcommand == 't') {

    786. 

  786. 					$x = ($a[0][0]); 

    787. 

  787. 					$y = ($a[1][0]); 

    788. 

  788. 

    789. 

  789. 					$x1 = $this->lastcontrolpoints[0];

    790. 

  790. 					$y1 = $this->lastcontrolpoints[1];

    791. 

  791. 

    792. 

  792. 					if($relative){

    793. 

  793. 						$pdfx = ($xbase + $x);

    794. 

  794. 						$pdfy = ($ybase - $y);

    795. 

  795. 

    796. 

  796. 						$pdfx1 = ($xbase + ($x1*2/3));

    797. 

  797. 						$pdfy1 = ($ybase - ($y1*2/3));

    798. 

  798. 						$pdfx2 = ($xbase + $x - ($x1*2/3));

    799. 

  799. 						$pdfy2 = ($ybase -$y - ($y1*2/3));

    800. 

  800. 

    801. 

  801. 						$xbase += $x;

    802. 

  802. 						$ybase += -$y;

    803. 

  803. 					}

    804. 

  804. 					else{

    805. 

  805. 						$pdfx = $x;

    806. 

  806. 						$pdfy =  -$y;

    807. 

  807. 

    808. 

  808. 						$pdfx1 = ($xbase + ($x1*2/3));

    809. 

  809. 						$pdfy1 = ($ybase - ($y1*2/3));

    810. 

  810. 						$pdfx2 = ($x - ($x1*2/3));

    811. 

  811. 						$pdfy2 = (-$y - ($y1*2/3));

    812. 

  812. 

    813. 

  813. 						$xbase = $x;

    814. 

  814. 						$ybase = -$y;

    815. 

  815. 					}

    816. 

  816. 

    817. 

  817. 

    818. 

  818. 

    819. 

  819. 

    820. 

  820. 					$this->lastcontrolpoints = array(($x-$pdfx2),($y-$pdfy2));

    821. 

  821. 					$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $pdfx1, $pdfy1, $pdfx2, $pdfy2, $pdfx, $pdfy);

    822. 

  822. 

    823. 

  823. 

    824. 

  824. 				}

    825. 

  825. 				$this->lastcontrolpoints = array();

    826. 

  826. 			break;

    827. 

  827. 			case 'a':	// Elliptical arc

    828. 

  828. 				for($i = 0; $i<$ile_argumentow; $i += 7){

    829. 

  829. 					$rx = ($a[$i][0]); 

    830. 

  830. 					$ry = ($a[$i+1][0]); 

    831. 

  831. 					$angle = ($a[$i+2][0]); //x-axis-rotation 

    832. 

  832. 					$largeArcFlag = ($a[$i+3][0]); 

    833. 

  833. 					$sweepFlag = ($a[$i+4][0]); 

    834. 

  834. 					$x2 = ($a[$i+5][0]); 

    835. 

  835. 					$y2 = ($a[$i+6][0]); 

    836. 

  836. 					$x1 = $xbase;

    837. 

  837. 					$y1 = -$ybase;

    838. 

  838. 					if($relative){

    839. 

  839. 						$x2 = $xbase + $x2;

    840. 

  840. 						$y2 = -$ybase + $y2;

    841. 

  841. 						$xbase += ($a[$i+5][0]); 

    842. 

  842. 						$ybase += -($a[$i+6][0]); 

    843. 

  843. 					}

    844. 

  844. 					else{

    845. 

  845. 						$xbase = $x2;

    846. 

  846. 						$ybase = -$y2;

    847. 

  847. 					}

    848. 

  848. 					$path_cmd .= $this->Arcto($x1, $y1, $x2, $y2, $rx, $ry, $angle, $largeArcFlag, $sweepFlag);

    849. 

  849. 

    850. 

  850. 				}

    851. 

  851. 			break;

    852. 

  852. 			case'z':

    853. 

  853. 				$path_cmd .= 'h ';

    854. 

  854. 			break;

    855. 

  855. 			default:

    856. 

  856. 			break;

    857. 

  857. 			}

    858. 

  858. 

    859. 

  859. 		$this->lastcommand = $command;

    860. 

  860. 

    861. 

  861. 		return $path_cmd;

    862. 

  862. 

    863. 

  863. 	}

    864. 

  864. 

    865. 

  865. function Arcto($x1, $y1, $x2, $y2, $rx, $ry, $angle, $largeArcFlag, $sweepFlag) {

    866. 

  866. 

    867. 

  867. 	// 1. Treat out-of-range parameters as described in

    868. 

  868. 	// http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes

    869. 

  869. 	// If the endpoints (x1, y1) and (x2, y2) are identical, then this

    870. 

  870. 	// is equivalent to omitting the elliptical arc segment entirely

    871. 

  871. 	if ($x1 == $x2 && $y1 == $y2) return '';

    872. 

  872. 

    873. 

  873. 	// If rX = 0 or rY = 0 then this arc is treated as a straight line

    874. 

  874. 	// segment (a "lineto") joining the endpoints.

    875. 

  875. 	if ($rx == 0.0 || $ry == 0.0) {

    876. 

  876. 	//   return Lineto(x2, y2);	// ****

    877. 

  877. 	}

    878. 

  878. 

    879. 

  879. 	// If rX or rY have negative signs, these are dropped; the absolute

    880. 

  880. 	// value is used instead.

    881. 

  881. 	if ($rx<0.0) $rx = -$rx;

    882. 

  882. 	if ($ry<0.0) $ry = -$ry;

    883. 

  883. 

    884. 

  884. 	// 2. convert to center parameterization as shown in

    885. 

  885. 	// http://www.w3.org/TR/SVG/implnote.html

    886. 

  886. 	$sinPhi = sin(deg2rad($angle));

    887. 

  887. 	$cosPhi = cos(deg2rad($angle));

    888. 

  888. 

    889. 

  889. 	$x1dash =  $cosPhi * ($x1-$x2)/2.0 + $sinPhi * ($y1-$y2)/2.0;

    890. 

  890. 	$y1dash = -$sinPhi * ($x1-$x2)/2.0 + $cosPhi * ($y1-$y2)/2.0;

    891. 

  891. 

    892. 

  892. 

    893. 

  893. 	$numerator = $rx*$rx*$ry*$ry - $rx*$rx*$y1dash*$y1dash - $ry*$ry*$x1dash*$x1dash;

    894. 

  894. 

    895. 

  895. 	if ($numerator < 0.0) { 

    896. 

  896. 		//  If rX , rY and are such that there is no solution (basically,

    897. 

  897. 		//  the ellipse is not big enough to reach from (x1, y1) to (x2,

    898. 

  898. 		//  y2)) then the ellipse is scaled up uniformly until there is

    899. 

  899. 		//  exactly one solution (until the ellipse is just big enough).

    900. 

  900. 

    901. 

  901. 		// -> find factor s, such that numerator' with rx'=s*rx and

    902. 

  902. 		//    ry'=s*ry becomes 0 :

    903. 

  903. 		$s = sqrt(1.0 - $numerator/($rx*$rx*$ry*$ry));

    904. 

  904. 

    905. 

  905. 		$rx *= $s;

    906. 

  906. 		$ry *= $s;

    907. 

  907. 		$root = 0.0;

    908. 

  908. 

    909. 

  909. 	}

    910. 

  910. 	else {

    911. 

  911. 		$root = ($largeArcFlag == $sweepFlag ? -1.0 : 1.0) * sqrt( $numerator/($rx*$rx*$y1dash*$y1dash+$ry*$ry*$x1dash*$x1dash) );

    912. 

  912. 	}

    913. 

  913. 

    914. 

  914. 	$cxdash = $root*$rx*$y1dash/$ry;

    915. 

  915. 	$cydash = -$root*$ry*$x1dash/$rx;

    916. 

  916. 

    917. 

  917. 	$cx = $cosPhi * $cxdash - $sinPhi * $cydash + ($x1+$x2)/2.0;

    918. 

  918. 	$cy = $sinPhi * $cxdash + $cosPhi * $cydash + ($y1+$y2)/2.0;

    919. 

  919. 

    920. 

  920. 

    921. 

  921. 	$theta1 = $this->CalcVectorAngle(1.0, 0.0, ($x1dash-$cxdash)/$rx, ($y1dash-$cydash)/$ry);

    922. 

  922. 	$dtheta = $this->CalcVectorAngle(($x1dash-$cxdash)/$rx, ($y1dash-$cydash)/$ry, (-$x1dash-$cxdash)/$rx, (-$y1dash-$cydash)/$ry);

    923. 

  923. 	if (!$sweepFlag && $dtheta>0)

    924. 

  924. 		$dtheta -= 2.0*M_PI;

    925. 

  925. 	else if ($sweepFlag && $dtheta<0)

    926. 

  926. 		$dtheta += 2.0*M_PI;

    927. 

  927. 

    928. 

  928. 	// 3. convert into cubic bezier segments <= 90deg

    929. 

  929. 	$segments = ceil(abs($dtheta/(M_PI/2.0)));

    930. 

  930. 	$delta = $dtheta/$segments;

    931. 

  931. 	$t = 8.0/3.0 * sin($delta/4.0) * sin($delta/4.0) / sin($delta/2.0);

    932. 

  932. 	$coords = array();

    933. 

  933. 	for ($i = 0; $i < $segments; $i++) {

    934. 

  934. 		$cosTheta1 = cos($theta1);

    935. 

  935. 		$sinTheta1 = sin($theta1);

    936. 

  936. 		$theta2 = $theta1 + $delta;

    937. 

  937. 		$cosTheta2 = cos($theta2);

    938. 

  938. 		$sinTheta2 = sin($theta2);

    939. 

  939. 

    940. 

  940. 		// a) calculate endpoint of the segment:

    941. 

  941. 		$xe = $cosPhi * $rx*$cosTheta2 - $sinPhi * $ry*$sinTheta2 + $cx;

    942. 

  942. 		$ye = $sinPhi * $rx*$cosTheta2 + $cosPhi * $ry*$sinTheta2 + $cy;

    943. 

  943. 

    944. 

  944. 		// b) calculate gradients at start/end points of segment:

    945. 

  945. 		$dx1 = $t * ( - $cosPhi * $rx*$sinTheta1 - $sinPhi * $ry*$cosTheta1);

    946. 

  946. 		$dy1 = $t * ( - $sinPhi * $rx*$sinTheta1 + $cosPhi * $ry*$cosTheta1);

    947. 

  947. 

    948. 

  948. 		$dxe = $t * ( $cosPhi * $rx*$sinTheta2 + $sinPhi * $ry*$cosTheta2);

    949. 

  949. 		$dye = $t * ( $sinPhi * $rx*$sinTheta2 - $cosPhi * $ry*$cosTheta2);

    950. 

  950. 

    951. 

  951. 		// c) draw the cubic bezier:

    952. 

  952. 		$coords[$i] = array(($x1+$dx1), ($y1+$dy1), ($xe+$dxe), ($ye+$dye), $xe, $ye);

    953. 

  953. 

    954. 

  954. 		// do next segment

    955. 

  955. 		$theta1 = $theta2;

    956. 

  956. 		$x1 = $xe;

    957. 

  957. 		$y1 = $ye;

    958. 

  958. 	}

    959. 

  959. 	$path = ' ';

    960. 

  960. 	foreach($coords AS $c) {

    961. 

  961. 		$cpx1 = $c[0];

    962. 

  962. 		$cpy1 = $c[1];

    963. 

  963. 		$cpx2 = $c[2];

    964. 

  964. 		$cpy2 = $c[3];

    965. 

  965. 		$x2 = $c[4];

    966. 

  966. 		$y2 = $c[5];

    967. 

  967. 		$path .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $cpx1, -$cpy1, $cpx2, -$cpy2, $x2, -$y2)  ."\n";

    968. 

  968. 	}

    969. 

  969. 	return $path ;

    970. 

  970. }

    971. 

  971. 

    972. 

  972. 

    973. 

  973. 	function CalcVectorAngle($ux, $uy, $vx, $vy) {

    974. 

  974. 		$ta = atan2($uy, $ux);

    975. 

  975. 		$tb = atan2($vy, $vx);

    976. 

  976. 		if ($tb >= $ta)

    977. 

  977. 			return ($tb-$ta);

    978. 

  978. 		return (6.28318530718 - ($ta-$tb));

    979. 

  979. 	}

    980. 

  980. 

    981. 

  981. 	//

    982. 

  982. 	//	fonction retracant les <rect />

    983. 

  983. 	function svgRect($arguments){

    984. 

  984. 

    985. 

  985. 		$x = $arguments['x']; 

    986. 

  986. 		$y = $arguments['y']; 

    987. 

  987. 		$h = $arguments['h']; 

    988. 

  988. 		$w = $arguments['w']; 

    989. 

  989. 		$rx = ($arguments['rx']/2); 

    990. 

  990. 		$ry = ($arguments['ry']/2); 

    991. 

  991. 

    992. 

  992. 		if ($rx>0 and $ry == 0){$ry = $rx;}

    993. 

  993. 		if ($ry>0 and $rx == 0){$rx = $ry;}

    994. 

  994. 

    995. 

  995. 		if ($rx == 0 and $ry == 0){

    996. 

  996. 			//	trace un rectangle sans angle arrondit

    997. 

  997. 			$path_cmd = sprintf('%.3f %.3f m ', ($x), -($y));

    998. 

  998. 			$path_cmd .= sprintf('%.3f %.3f l ', (($x+$w)), -($y));

    999. 

  999. 			$path_cmd .= sprintf('%.3f %.3f l ', (($x+$w)), -(($y+$h)));

    1000. 

  1000. 			$path_cmd .= sprintf('%.3f %.3f l ', ($x), -(($y+$h)));

    1001. 

  1001. 			$path_cmd .= sprintf('%.3f %.3f l h ', ($x), -($y));

    1002. 

  1002. 

    1003. 

  1003. 			

    1004. 

  1004. 		}

    1005. 

  1005. 		else {

    1006. 

  1006. 			//	trace un rectangle avec les arrondit

    1007. 

  1007. 			//	les points de controle du bezier sont deduis grace a la constante kappa

    1008. 

  1008. 			$kappa = 4*(sqrt(2)-1)/3;

    1009. 

  1009. 

    1010. 

  1010. 			$kx = $kappa*$rx;

    1011. 

  1011. 			$ky = $kappa*$ry;

    1012. 

  1012. 

    1013. 

  1013. 			$path_cmd = sprintf('%.3f %.3f m ', $x+($rx), -$y);

    1014. 

  1014. 			$path_cmd .= sprintf('%.3f %.3f l ', $x+(($w-$rx)), -$y);

    1015. 

  1015. 			$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x+(($w-$rx+$kx)), -$y, $x+($w), -$y+((-$ry+$ky)), $x+($w), -$y+(-$ry) );

    1016. 

  1016. 			$path_cmd .= sprintf('%.3f %.3f l ', $x+($w), -$y+((-$h+$ry)));

    1017. 

  1017. 		 	$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x+($w), -$y+((-$h-$ky+$ry)), $x+(($w-$rx+$kx)), -$y+(-$h), $x+(($w-$rx)), -$y+(-$h) );

    1018. 

  1018. 

    1019. 

  1019. 			$path_cmd .= sprintf('%.3f %.3f l ', $x+($rx), -$y+(-$h));

    1020. 

  1020. 			$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x+(($rx-$kx)), -$y+(-$h), $x, -$y+((-$h-$ky+$ry)), $x, -$y+((-$h+$ry)) );

    1021. 

  1021. 			$path_cmd .= sprintf('%.3f %.3f l ', $x, -$y+(-$ry));

    1022. 

  1022. 			$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c h ', $x, -$y+((-$ry+$ky)), $x+(($rx-$kx)), -$y, $x+($rx), -$y );

    1023. 

  1023. 

    1024. 

  1024. 

    1025. 

  1025. 		}

    1026. 

  1026. 		return $path_cmd;

    1027. 

  1027. 	}

    1028. 

  1028. 

    1029. 

  1029. 	//

    1030. 

  1030. 	//	fonction retracant les <ellipse /> et <circle />

    1031. 

  1031. 	//	 le cercle est tracé grave a 4 bezier cubic, les poitn de controles

    1032. 

  1032. 	//	sont deduis grace a la constante kappa * rayon

    1033. 

  1033. 	function svgEllipse($arguments){

    1034. 

  1034. 		$kappa = 4*(sqrt(2)-1)/3;

    1035. 

  1035. 

    1036. 

  1036. 		$cx = $arguments['cx'] ;

    1037. 

  1037. 		$cy = $arguments['cy'] ;

    1038. 

  1038. 		$rx = $arguments['rx'] ;

    1039. 

  1039. 		$ry = $arguments['ry'] ;

    1040. 

  1040. 

    1041. 

  1041. 		$x1 = $cx;

    1042. 

  1042. 		$y1 = -$cy+$ry;

    1043. 

  1043. 

    1044. 

  1044. 		$x2 = $cx+$rx;

    1045. 

  1045. 		$y2 = -$cy;

    1046. 

  1046. 

    1047. 

  1047. 		$x3 = $cx;

    1048. 

  1048. 		$y3 = -$cy-$ry;

    1049. 

  1049. 

    1050. 

  1050. 		$x4 = $cx-$rx;

    1051. 

  1051. 		$y4 = -$cy;

    1052. 

  1052. 

    1053. 

  1053. 		$path_cmd = sprintf('%.3f %.3f m ', $x1, $y1);

    1054. 

  1054. 		$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x1+($rx*$kappa), $y1, $x2, $y2+($ry*$kappa), $x2, $y2);

    1055. 

  1055. 		$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x2, $y2-($ry*$kappa), $x3+($rx*$kappa), $y3, $x3, $y3);

    1056. 

  1056. 		$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x3-($rx*$kappa), $y3, $x4, $y4-($ry*$kappa), $x4, $y4);

    1057. 

  1057. 		$path_cmd .= sprintf('%.3f %.3f %.3f %.3f %.3f %.3f c ', $x4, $y4+($ry*$kappa), $x1-($rx*$kappa), $y1, $x1, $y1);

    1058. 

  1058. 		$path_cmd .= 'h ';

    1059. 

  1059. 

    1060. 

  1060. 		return $path_cmd;

    1061. 

  1061. 

    1062. 

  1062. 	}

    1063. 

  1063. 

    1064. 

  1064. 	//

    1065. 

  1065. 	//	fonction retracant les <polyline /> et les <line />

    1066. 

  1066. 	function svgPolyline($arguments){

    1067. 

  1067. 		$xbase = $arguments[0] ;

    1068. 

  1068. 		$ybase = - $arguments[1] ;

    1069. 

  1069. 		$path_cmd = sprintf('%.3f %.3f m ', $xbase, $ybase);

    1070. 

  1070. 		for ($i = 2; $i<count($arguments);$i += 2) {

    1071. 

  1071. 

    1072. 

  1072. 			$tmp_x = $arguments[$i] ;

    1073. 

  1073. 			$tmp_y = - $arguments[($i+1)] ;

    1074. 

  1074. 			$path_cmd .= sprintf('%.3f %.3f l ', $tmp_x, $tmp_y);

    1075. 

  1075. 		}

    1076. 

  1076. 

    1077. 

  1077. 	//	$path_cmd .= 'h '; // ?? In error - don't close subpath here

    1078. 

  1078. 		return $path_cmd;

    1079. 

  1079. 

    1080. 

  1080. 	}

    1081. 

  1081. 

    1082. 

  1082. 	//

    1083. 

  1083. 	//	fonction retracant les <polygone />

    1084. 

  1084. 	function svgPolygon($arguments){

    1085. 

  1085. 		$xbase = $arguments[0] ;

    1086. 

  1086. 		$ybase = - $arguments[1] ;

    1087. 

  1087. 		$path_cmd = sprintf('%.3f %.3f m ', $xbase, $ybase);

    1088. 

  1088. 		for ($i = 2; $i<count($arguments);$i += 2) {

    1089. 

  1089. 			$tmp_x = $arguments[$i] ;

    1090. 

  1090. 			$tmp_y = - $arguments[($i+1)] ;

    1091. 

  1091. 

    1092. 

  1092. 			$path_cmd .= sprintf('%.3f %.3f l ', $tmp_x, $tmp_y);

    1093. 

  1093. 

    1094. 

  1094. 		}

    1095. 

  1095. 		$path_cmd .= sprintf('%.3f %.3f l ', $xbase, $ybase);

    1096. 

  1096. 		$path_cmd .= 'h ';

    1097. 

  1097. 		return $path_cmd;

    1098. 

  1098. 

    1099. 

  1099. 	}

    1100. 

  1100. 

    1101. 

  1101. 	//

    1102. 

  1102. 	//	write string to image

    1103. 

  1103. 	function svgText(){

    1104. 

  1104. 		// $tmp = count($this->txt_style)-1;

    1105. 

  1105. 		$current_style = array_pop($this->txt_style);

    1106. 

  1106. 		$style = '';

    1107. 

  1107. 		if(isset($this->txt_data[2]))

    1108. 

  1108. 		{

    1109. 

  1109. 			// select font

    1110. 

  1110. 			$style .= ($current_style['font-weight'] == 'bold')?'B':'';

    1111. 

  1111. 			$style .= ($current_style['font-style'] == 'italic')?'I':'';

    1112. 

  1112. 			$size = $current_style['font-size'];

    1113. 

  1113. 			$current_style['font-family'] = $this->mpdf_ref->SetFont($current_style['font-family'],$style,$current_style['font-size'],false);

    1114. 

  1114. 

    1115. 

  1115. 			$col = $this->mpdf_ref->ConvertColor($current_style['fill']);

    1116. 

  1116. 

    1117. 

  1117. 			$x = $this->txt_data[0];

    1118. 

  1118. 			$y = $this->txt_data[1];

    1119. 

  1119. 			$txt = $this->txt_data[2];

    1120. 

  1120. 			$txt = trim($txt);

    1121. 

  1121. 

    1122. 

  1122. 			$txt = $this->mpdf_ref->purify_utf8_text($txt);

    1123. 

  1123. 			if ($this->mpdf_ref->text_input_as_HTML) {

    1124. 

  1124. 				$txt = $this->mpdf_ref->all_entities_to_utf8($txt);

    1125. 

  1125. 			}

    1126. 

  1126. 			if (!$this->mpdf_ref->is_MB) { $txt = mb_convert_encoding($txt,$this->mpdf_ref->mb_enc,'UTF-8'); }

    1127. 

  1127. 			$this->mpdf_ref->magic_reverse_dir($txt);	

    1128. 

  1128. 			$this->mpdf_ref->ConvertIndic($txt);

    1129. 

  1129. 

    1130. 

  1130. 			if ($current_style['text-anchor']=='middle') {

    1131. 

  1131. 				$tw = $this->mpdf_ref->GetStringWidth($txt)*2.835/2;

    1132. 

  1132. 			}

    1133. 

  1133. 			else if ($current_style['text-anchor']=='end') {

    1134. 

  1134. 				$tw = $this->mpdf_ref->GetStringWidth($txt)*2.835;

    1135. 

  1135. 			}

    1136. 

  1136. 			else $tw = 0;

    1137. 

  1137. 

    1138. 

  1138. 			if ($this->mpdf_ref->useSubsets && $this->mpdf_ref->CurrentFont['type']=='Type1subset' && !$this->mpdf_ref->isCJK && !$this->mpdf_ref->usingCoreFont) {

    1139. 

  1139. 				$txt = $this->mpdf_ref->UTF8toSubset($txt);

    1140. 

  1140. 			}

    1141. 

  1141. 			else {

    1142. 

  1142. 				if ($this->mpdf_ref->is_MB && !$this->mpdf_ref->usingCoreFont) {

    1143. 

  1143. 					$txt= $this->mpdf_ref->UTF8ToUTF16BE($txt, false);

    1144. 

  1144. 				}

    1145. 

  1145. 				$txt='('.$this->mpdf_ref->_escape($txt).')'; 

    1146. 

  1146. 			}

    1147. 

  1147. 			$this->mpdf_ref->CurrentFont['used']= true;

    1148. 

  1148. 

    1149. 

  1149. 			$pdfx = ($x - $tw);

    1150. 

  1150. 			$pdfy =  -$y  ;

    1151. 

  1151. 			$xbase = $x;

    1152. 

  1152. 			$ybase = -$y;

    1153. 

  1153. 

    1154. 

  1154. 			$path_cmd =  sprintf('q BT /F%d %.3f Tf %.3f %.3f Td 0 Tr %.3f %.3f %.3f rg %s Tj ET Q ',$this->mpdf_ref->CurrentFont['i'],$this->mpdf_ref->FontSizePt,$pdfx,$pdfy,$col['R']/255,$col['G']/255,$col['B']/255,$txt);

    1155. 

  1155. 

    1156. 

  1156. 			unset($this->txt_data[0], $this->txt_data[1],$this->txt_data[2]);

    1157. 

  1157. 		}

    1158. 

  1158. 		else

    1159. 

  1159. 		{

    1160. 

  1160. 			die("No string to write!");

    1161. 

  1161. 		}

    1162. 

  1162. 		$path_cmd .= 'h ';

    1163. 

  1163. 		return $path_cmd;

    1164. 

  1164. 	}

    1165. 

  1165. 

    1166. 

  1166. 

    1167. 

  1167. function svgDefineTxtStyle($critere_style)

    1168. 

  1168. {

    1169. 

  1169. 		// get copy of current/default txt style, and modify it with supplied attributes

    1170. 

  1170. 		$tmp = count($this->txt_style)-1;

    1171. 

  1171. 		$current_style = $this->txt_style[$tmp];

    1172. 

  1172. 

    1173. 

  1173. 		if (isset($critere_style['font'])){

    1174. 

  1174. 

    1175. 

  1175. 			// [ [ <'font-style'> || <'font-variant'> || <'font-weight'> ]?<'font-size'> [ / <'line-height'> ]? <'font-family'> ]

    1176. 

  1176. 

    1177. 

  1177. 			$tmp = preg_replace("/(.*)(italic|oblique)(.*)/i","$2",$critere_style['font']);

    1178. 

  1178. 			if ($tmp != $critere_style['font']){ 

    1179. 

  1179. 				if($tmp == 'oblique'){

    1180. 

  1180. 					$tmp = 'italic';

    1181. 

  1181. 				}

    1182. 

  1182. 				$current_style['font-style'] = $tmp;

    1183. 

  1183. 			}

    1184. 

  1184. 			$tmp = preg_replace("/(.*)(bold|bolder)(.*)/i","$2",$critere_style['font']);

    1185. 

  1185. 			if ($tmp != $critere_style['font']){ 

    1186. 

  1186. 				if($tmp == 'bolder'){

    1187. 

  1187. 					$tmp = 'bold';

    1188. 

  1188. 				}

    1189. 

  1189. 				$current_style['font-weight'] = $tmp;

    1190. 

  1190. 			}

    1191. 

  1191. 			

    1192. 

  1192. 			// select digits not followed by percent sign nor preceeded by forward slash

    1193. 

  1193. 			$tmp = preg_replace("/(.*)\b(\d+)[\b|\/](.*)/i","$2",$critere_style['font']);

    1194. 

  1194. 			if ($tmp != $critere_style['font']){ $current_style['font-size'] = $tmp; }

    1195. 

  1195. 			

    1196. 

  1196. 		}

    1197. 

  1197. 

    1198. 

  1198. 		if(isset($critere_style['fill'])){

    1199. 

  1199. 			$current_style['fill'] = $critere_style['fill'];

    1200. 

  1200. 		}

    1201. 

  1201. 		

    1202. 

  1202. 		if(isset($critere_style['font-style'])){

    1203. 

  1203. 			if(strtolower($critere_style['font-style']) == 'oblique') 

    1204. 

  1204. 			{

    1205. 

  1205. 				$critere_style['font-style'] = 'italic';

    1206. 

  1206. 			}

    1207. 

  1207. 			$current_style['font-style'] = $critere_style['font-style'];

    1208. 

  1208. 		}

    1209. 

  1209. 		

    1210. 

  1210. 		if(isset($critere_style['font-weight'])){

    1211. 

  1211. 			if(strtolower($critere_style['font-weight']) == 'bolder')

    1212. 

  1212. 			{

    1213. 

  1213. 				$critere_style['font-weight'] = 'bold';

    1214. 

  1214. 			}

    1215. 

  1215. 			$current_style['font-weight'] = $critere_style['font-weight'];

    1216. 

  1216. 		}

    1217. 

  1217. 		

    1218. 

  1218. 		if(isset($critere_style['font-size'])){

    1219. 

  1219. 			$current_style['font-size'] = $this->mpdf_ref->ConvertSize($critere_style['font-size'])* 2.835;

    1220. 

  1220. 		}

    1221. 

  1221. 		

    1222. 

  1222. 		if(isset($critere_style['font-family'])){

    1223. 

  1223. 			$current_style['font-family'] = $critere_style['font-family'];

    1224. 

  1224. 		}

    1225. 

  1225. 	

    1226. 

  1226. 		if(isset($critere_style['text-anchor'])){

    1227. 

  1227. 			$current_style['text-anchor'] = $critere_style['text-anchor'];

    1228. 

  1228. 		}

    1229. 

  1229. 	

    1230. 

  1230. 	// add current style to text style array (will remove it later after writing text to svg_string)

    1231. 

  1231. 	array_push($this->txt_style,$current_style);

    1232. 

  1232. }

    1233. 

  1233. 

    1234. 

  1234. 

    1235. 

  1235. 

    1236. 

  1236. 	//

    1237. 

  1237. 	//	fonction ajoutant un gradient

    1238. 

  1238. 	function svgAddGradient($id,$array_gradient){

    1239. 

  1239. 

    1240. 

  1240. 		$this->svg_gradient[$id] = $array_gradient;

    1241. 

  1241. 

    1242. 

  1242. 	}

    1243. 

  1243. 	//

    1244. 

  1244. 	//	Ajoute une couleur dans le gradient correspondant

    1245. 

  1245. 

    1246. 

  1246. 	//

    1247. 

  1247. 	//	function ecrivant dans le svgstring

    1248. 

  1248. 	function svgWriteString($content){

    1249. 

  1249. 

    1250. 

  1250. 		$this->svg_string .= $content;

    1251. 

  1251. 

    1252. 

  1252. 	}

    1253. 

  1253. 

    1254. 

  1254. 

    1255. 

  1255. 

    1256. 

  1256. 	//	analise le svg et renvoie aux fonctions precedente our le traitement

    1257. 

  1257. 	function ImageSVG($data){

    1258. 

  1258. 		$this->svg_info = array();

    1259. 

  1259. 		$this->svg_info['data'] = $data;

    1260. 

  1260. 

    1261. 

  1261. 		$this->svg_string = '';

    1262. 

  1262. 		

    1263. 

  1263. 		//

    1264. 

  1264. 		//	chargement unique des fonctions

    1265. 

  1265. 		if(!function_exists(xml_svg2pdf_start)){

    1266. 

  1266. 

    1267. 

  1267. 			function xml_svg2pdf_start($parser, $name, $attribs){

    1268. 

  1268. 				//

    1269. 

  1269. 				//	definition

    1270. 

  1270. 				global $svg_class, $last_gradid;

    1271. 

  1271. 				switch (strtolower($name)){

    1272. 

  1272. 

    1273. 

  1273. 				case 'svg':

    1274. 

  1274. 					$svg_class->svgOffset($attribs);

    1275. 

  1275. 					break;

    1276. 

  1276. 

    1277. 

  1277. 				case 'path':

    1278. 

  1278. 					$path = $attribs['d'];

    1279. 

  1279. 					preg_match_all('/([a-z]|[A-Z])([ ,\-.\d]+)*/', $path, $commands, PREG_SET_ORDER);

    1280. 

  1280. 					$path_cmd = '';

    1281. 

  1281. 					foreach($commands as $c){

    1282. 

  1282. 						if(count($c)==3){

    1283. 

  1283. 							list($tmp, $command, $arguments) = $c;

    1284. 

  1284. 						}

    1285. 

  1285. 						else{

    1286. 

  1286. 							list($tmp, $command) = $c;

    1287. 

  1287. 							$arguments = '';

    1288. 

  1288. 						}

    1289. 

  1289. 

    1290. 

  1290. 						$path_cmd .= $svg_class->svgPath($command, $arguments);

    1291. 

  1291. 					}

    1292. 

  1292. 					$critere_style = $attribs;

    1293. 

  1293. 					unset($critere_style['d']);

    1294. 

  1294. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1295. 

  1295. 					break;

    1296. 

  1296. 

    1297. 

  1297. 				case 'rect':

    1298. 

  1298. 					if (!isset($attribs['x'])) {$attribs['x'] = 0;}

    1299. 

  1299. 					if (!isset($attribs['y'])) {$attribs['y'] = 0;}

    1300. 

  1300. 					if (!isset($attribs['rx'])) {$attribs['rx'] = 0;}

    1301. 

  1301. 					if (!isset($attribs['ry'])) {$attribs['ry'] = 0;}

    1302. 

  1302. 					$arguments = array(

    1303. 

  1303. 						'x' => $attribs['x'],

    1304. 

  1304. 						'y' => $attribs['y'],

    1305. 

  1305. 						'w' => $attribs['width'],

    1306. 

  1306. 						'h' => $attribs['height'],

    1307. 

  1307. 						'rx' => $attribs['rx'],

    1308. 

  1308. 						'ry' => $attribs['ry']

    1309. 

  1309. 					);

    1310. 

  1310. 					$path_cmd =  $svg_class->svgRect($arguments);

    1311. 

  1311. 					$critere_style = $attribs;

    1312. 

  1312. 					unset($critere_style['x'],$critere_style['y'],$critere_style['rx'],$critere_style['ry'],$critere_style['height'],$critere_style['width']);

    1313. 

  1313. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1314. 

  1314. 					break;

    1315. 

  1315. 

    1316. 

  1316. 				case 'circle':

    1317. 

  1317. 					if (!isset($attribs['cx'])) {$attribs['cx'] = 0;}

    1318. 

  1318. 					if (!isset($attribs['cy'])) {$attribs['cy'] = 0;}

    1319. 

  1319. 					$arguments = array(

    1320. 

  1320. 						'cx' => $attribs['cx'],

    1321. 

  1321. 						'cy' => $attribs['cy'],

    1322. 

  1322. 						'rx' => $attribs['r'],

    1323. 

  1323. 						'ry' => $attribs['r']

    1324. 

  1324. 					);

    1325. 

  1325. 					$path_cmd =  $svg_class->svgEllipse($arguments);

    1326. 

  1326. 					$critere_style = $attribs;

    1327. 

  1327. 					unset($critere_style['cx'],$critere_style['cy'],$critere_style['r']);

    1328. 

  1328. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1329. 

  1329. 					break;

    1330. 

  1330. 

    1331. 

  1331. 				case 'ellipse':

    1332. 

  1332. 					if (!isset($attribs['cx'])) {$attribs['cx'] = 0;}

    1333. 

  1333. 					if (!isset($attribs['cy'])) {$attribs['cy'] = 0;}

    1334. 

  1334. 					$arguments = array(

    1335. 

  1335. 						'cx' => $attribs['cx'],

    1336. 

  1336. 						'cy' => $attribs['cy'],

    1337. 

  1337. 						'rx' => $attribs['rx'],

    1338. 

  1338. 						'ry' => $attribs['ry']

    1339. 

  1339. 					);

    1340. 

  1340. 					$path_cmd =  $svg_class->svgEllipse($arguments);

    1341. 

  1341. 					$critere_style = $attribs;

    1342. 

  1342. 					unset($critere_style['cx'],$critere_style['cy'],$critere_style['rx'],$critere_style['ry']);

    1343. 

  1343. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1344. 

  1344. 					break;

    1345. 

  1345. 

    1346. 

  1346. 				case 'line':

    1347. 

  1347. 					$arguments = array($attribs['x1'],$attribs['y1'],$attribs['x2'],$attribs['y2']);

    1348. 

  1348. 					$path_cmd =  $svg_class->svgPolyline($arguments);

    1349. 

  1349. 					$critere_style = $attribs;

    1350. 

  1350. 					unset($critere_style['x1'],$critere_style['y1'],$critere_style['x2'],$critere_style['y2']);

    1351. 

  1351. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1352. 

  1352. 					break;

    1353. 

  1353. 

    1354. 

  1354. 				case 'polyline':

    1355. 

  1355. 					$path = $attribs['points'];

    1356. 

  1356. 					preg_match_all('/[0-9\-\.]*/',$path, $tmp, PREG_SET_ORDER);

    1357. 

  1357. 					$arguments = array();

    1358. 

  1358. 					for ($i=0;$i<count($tmp);$i++){

    1359. 

  1359. 						if ($tmp[$i][0] !=''){

    1360. 

  1360. 							array_push($arguments, $tmp[$i][0]);

    1361. 

  1361. 						}

    1362. 

  1362. 					}

    1363. 

  1363. 					$path_cmd =  $svg_class->svgPolyline($arguments);

    1364. 

  1364. 					$critere_style = $attribs;

    1365. 

  1365. 					unset($critere_style['points']);

    1366. 

  1366. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1367. 

  1367. 					break;

    1368. 

  1368. 

    1369. 

  1369. 				case 'polygon':

    1370. 

  1370. 					$path = $attribs['points'];

    1371. 

  1371. 					preg_match_all('/([\-]*[0-9\.]+)/',$path, $tmp);

    1372. 

  1372. 					$arguments = array();

    1373. 

  1373. 					for ($i=0;$i<count($tmp[0]);$i++){

    1374. 

  1374. 						if ($tmp[0][$i] !=''){

    1375. 

  1375. 							array_push($arguments, $tmp[0][$i]);

    1376. 

  1376. 						}

    1377. 

  1377. 					}

    1378. 

  1378. 					$path_cmd =  $svg_class->svgPolygon($arguments);

    1379. 

  1379. 					//	definition du style de la forme:

    1380. 

  1380. 					$critere_style = $attribs;

    1381. 

  1381. 					unset($critere_style['points']);

    1382. 

  1382. 					$path_style = $svg_class->svgDefineStyle($critere_style);

    1383. 

  1383. 					break;

    1384. 

  1384. 

    1385. 

  1385. 				case 'lineargradient':

    1386. 

  1386. 						$tmp_gradient = array(

    1387. 

  1387. 							'type' => 'linear',

    1388. 

  1388. 							'info' => array(

    1389. 

  1389. 								'x1' => $attribs['x1'],

    1390. 

  1390. 								'y1' => $attribs['y1'],

    1391. 

  1391. 								'x2' => $attribs['x2'],

    1392. 

  1392. 								'y2' => $attribs['y2']

    1393. 

  1393. 							),

    1394. 

  1394. 							'transform' => $attribs['gradientTransform'],

    1395. 

  1395. 							'color' => array()

    1396. 

  1396. 						);

    1397. 

  1397. 

    1398. 

  1398. 						$last_gradid = $attribs['id'];

    1399. 

  1399. 

    1400. 

  1400. 						$svg_class->svgAddGradient($attribs['id'],$tmp_gradient);

    1401. 

  1401. 

    1402. 

  1402. 					break;

    1403. 

  1403. 

    1404. 

  1404. 				case 'radialgradient':

    1405. 

  1405. 

    1406. 

  1406. 						$tmp_gradient = array(

    1407. 

  1407. 							'type' => 'radial',

    1408. 

  1408. 							'info' => array(

    1409. 

  1409. 								'x0' => $attribs['cx'],

    1410. 

  1410. 								'y0' => $attribs['cy'],

    1411. 

  1411. 								'x1' => $attribs['fx'],

    1412. 

  1412. 								'y1' => $attribs['fy'],

    1413. 

  1413. 								'r' => $attribs['r']

    1414. 

  1414. 							),

    1415. 

  1415. 							'transform' => $attribs['gradientTransform'],

    1416. 

  1416. 							'color' => array()

    1417. 

  1417. 						);

    1418. 

  1418. 

    1419. 

  1419. 						$last_gradid = $attribs['id'];

    1420. 

  1420. 

    1421. 

  1421. 						$svg_class->svgAddGradient($attribs['id'],$tmp_gradient);

    1422. 

  1422. 

    1423. 

  1423. 					break;

    1424. 

  1424. 

    1425. 

  1425. 				case 'stop':

    1426. 

  1426. 

    1427. 

  1427. if (!$last_gradid) break;

    1428. 

  1428. 						if (isset($attribs['style']) AND !isset($attribs['stop-color'])){

    1429. 

  1429. 							$color = preg_replace('/stop-color:([0-9#]*)/i','$1',$attribs['style']);

    1430. 

  1430. 						} else {

    1431. 

  1431. 							$color = $attribs['stop-color'];

    1432. 

  1432. 						}

    1433. 

  1433. 						$col = $svg_class->mpdf_ref->ConvertColor($color);

    1434. 

  1434. 						$color_r = $col['R'];

    1435. 

  1435. 						$color_g = $col['G'];

    1436. 

  1436. 						$color_b = $col['B'];

    1437. 

  1437. 						$color_final = $path_style .= sprintf('%.3f %.3f %.3f',$color_r/255,$color_g/255,$color_b/255);

    1438. 

  1438. 						$tmp_color = array(

    1439. 

  1439. 							'color' => $color_final,

    1440. 

  1440. 							'offset' => $attribs['offset'],

    1441. 

  1441. 							'opacity' => $attribs['stop-opacity']

    1442. 

  1442. 						);

    1443. 

  1443. 						array_push($svg_class->svg_gradient[$last_gradid]['color'],$tmp_color);

    1444. 

  1444. 					break;

    1445. 

  1445. 

    1446. 

  1446. 

    1447. 

  1447. 				case 'g':

    1448. 

  1448. 						$array_style = $svg_class->svgDefineStyle($attribs);

    1449. 

  1449. 						if ($array_style['transformations']) {

    1450. 

  1450. 							$svg_class->svgWriteString(' q '.$array_style['transformations']);

    1451. 

  1451. 						}

    1452. 

  1452. 						array_push($svg_class->svg_style,$array_style);

    1453. 

  1453. 					break;

    1454. 

  1454. 

    1455. 

  1455. 				case 'text':

    1456. 

  1456. 						$svg_class->txt_data = array();

    1457. 

  1457. 						$svg_class->txt_data[0] = $attribs['x'];

    1458. 

  1458. 						$svg_class->txt_data[1] = $attribs['y'];

    1459. 

  1459. 						$critere_style = $attribs;

    1460. 

  1460. 						unset($critere_style['x'], $critere_style['y']);

    1461. 

  1461. 						$svg_class->svgDefineTxtStyle($critere_style);

    1462. 

  1462. 

    1463. 

  1463. 					break;

    1464. 

  1464. 				}

    1465. 

  1465. 

    1466. 

  1466. 				//

    1467. 

  1467. 				//insertion des path et du style dans le flux de donné general.

    1468. 

  1468. 				if (isset($path_cmd)){

    1469. 

  1469. 					$get_style = $svg_class->svgStyle($path_style, $attribs, strtolower($name));

    1470. 

  1470. 					if ($path_style['transformations']) {	// transformation on an element

    1471. 

  1471. 						$svg_class->svgWriteString(" q ".$path_style['transformations']. "$path_cmd $get_style" . " Q\n");

    1472. 

  1472. 					}

    1473. 

  1473. 					else {

    1474. 

  1474. 						$svg_class->svgWriteString("$path_cmd $get_style\n");

    1475. 

  1475. 					}

    1476. 

  1476. 				}

    1477. 

  1477. 			}

    1478. 

  1478. 

    1479. 

  1479. 			function characterData($parser, $data)

    1480. 

  1480. 			{

    1481. 

  1481. 				global $svg_class;

    1482. 

  1482. 				if(isset($svg_class->txt_data[2]))

    1483. 

  1483. 				{

    1484. 

  1484. 					$svg_class->txt_data[2] .= $data;

    1485. 

  1485. 				}

    1486. 

  1486. 				else

    1487. 

  1487. 				{

    1488. 

  1488. 					$svg_class->txt_data[2] = $data;

    1489. 

  1489. 				}

    1490. 

  1490. 			}

    1491. 

  1491. 

    1492. 

  1492. 

    1493. 

  1493. 			function xml_svg2pdf_end($parser, $name){

    1494. 

  1494. 				global $svg_class;

    1495. 

  1495. 				switch($name){

    1496. 

  1496. 					case "g":

    1497. 

  1497. 						$tmp = count($svg_class->svg_style)-1;

    1498. 

  1498. 						$current_style = $svg_class->svg_style[$tmp];

    1499. 

  1499. 						if ($current_style['transformations']) {

    1500. 

  1500. 							$svg_class->svgWriteString(" Q ");

    1501. 

  1501. 						}

    1502. 

  1502. 						array_pop($svg_class->svg_style);

    1503. 

  1503. 					break;

    1504. 

  1504. 					case 'radialgradient':

    1505. 

  1505. 					case 'lineargradient':

    1506. 

  1506. 						$last_gradid = '';

    1507. 

  1507. 					break;

    1508. 

  1508. 					case "text":

    1509. 

  1509. 						$path_cmd = $svg_class->svgText();

    1510. 

  1510. 						// echo 'path >> '.$path_cmd."<br><br>";

    1511. 

  1511. 						// echo "style >> ".$get_style[1]."<br><br>";

    1512. 

  1512. 						$svg_class->svgWriteString($path_cmd);

    1513. 

  1513. 					break;

    1514. 

  1514. 				}

    1515. 

  1515. 

    1516. 

  1516. 			}

    1517. 

  1517. 

    1518. 

  1518. 		}

    1519. 

  1519. 

    1520. 

  1520. 		$svg2pdf_xml='';

    1521. 

  1521. 		global $svg_class;

    1522. 

  1522. 

    1523. 

  1523. 		$svg_class = $this;

    1524. 

  1524.  		$svg2pdf_xml_parser = xml_parser_create("utf-8");

    1525. 

  1525. 		xml_parser_set_option($svg2pdf_xml_parser, XML_OPTION_CASE_FOLDING, false);

    1526. 

  1526. 		xml_set_element_handler($svg2pdf_xml_parser, "xml_svg2pdf_start", "xml_svg2pdf_end");

    1527. 

  1527. 		xml_set_character_data_handler($svg2pdf_xml_parser, "characterData");

    1528. 

  1528. 		xml_parse($svg2pdf_xml_parser, $data);

    1529. 

  1529. 

    1530. 

  1530. 		return array('x'=>$this->svg_info['x'],'y'=>-$this->svg_info['y'],'w'=>$this->svg_info['w'],'h'=>-$this->svg_info['h'],'data'=>$svg_class->svg_string);

    1531. 

  1531. 

    1532. 

  1532. 	}

    1533. 

  1533. 

    1534. 

  1534. }

    1535. 

  1535. 

    1536. 

  1536. ?>
    1537.