---

<th><thead><tr><tt><u><ul>');
			//replace some blank characters
			$html = preg_replace('/<pre/', '<xre', $html); // preserve pre tag
			$html = preg_replace('/<(table|tr|td|th|tcpdf|blockquote|dd|div|dl|dt|form|h1|h2|h3|h4|h5|h6|br|hr|li|ol|ul|p)([^\>]*)>[\n\r\t]+/', '<\\1\\2>', $html);
			$html = preg_replace('@(\r\n|\r)@', "\n", $html);
			$repTable = array("\t" => ' ', "\0" => ' ', "\x0B" => ' ', "\\" => "\\\\");
			$html = strtr($html, $repTable);
			$offset = 0;
			while (($offset < strlen($html)) AND ($pos = strpos($html, '</pre>', $offset)) !== false) {
				$html_a = substr($html, 0, $offset);
				$html_b = substr($html, $offset, ($pos - $offset + 6));
				while (preg_match("'<xre([^\>]*)>(.*?)\n(.*?)</pre>'si", $html_b)) {
					// preserve newlines on <pre> tag
					$html_b = preg_replace("'<xre([^\>]*)>(.*?)\n(.*?)</pre>'si", "<xre\\1>\\2<br />\\3</pre>", $html_b);
				}
				$html = $html_a.$html_b.substr($html, $pos + 6);
				$offset = strlen($html_a.$html_b);
			}
			$offset = 0;
			while (($offset < strlen($html)) AND ($pos = strpos($html, '', $offset)) !== false) {
				$html_a = substr($html, 0, $offset);
				$html_b = substr($html, $offset, ($pos - $offset + 11));
				while (preg_match("']*)>(.*?)\n(.*?)'si", $html_b)) {
					// preserve newlines on  tag
					$html_b = preg_replace("'<textarea([^\>]*)>(.*?)\n(.*?)'si", "\\2\\3", $html_b);
					$html_b = preg_replace("']*)>(.*?)[\"](.*?)'si", "\\2''\\3", $html_b);
				}
				$html = $html_a.$html_b.substr($html, $pos + 11);
				$offset = strlen($html_a.$html_b);
			}
			$html = preg_replace("'([\s]*)([\s]*)'si", "", $html);
			$offset = 0;
			while (($offset < strlen($html)) AND ($pos = strpos($html, '', $offset)) !== false) {
				$html_a = substr($html, 0, $offset);
				$html_b = substr($html, $offset, ($pos - $offset + 9));
				while (preg_match("']*)>(.*?)'si", $html_b)) {
					$html_b = preg_replace("']*)>(.*?)'si", "\\2\t\\4\r", $html_b);
					$html_b = preg_replace("']*)>(.*?)'si", "\\2\r", $html_b);
				}
				$html = $html_a.$html_b.substr($html, $pos + 9);
				$offset = strlen($html_a.$html_b);
			}
			$html = preg_replace("']*)>'si", "'si", "\" />", $html);
			$html = str_replace("\n", ' ', $html);
			// restore textarea newlines
			$html = str_replace('', "\n", $html);
			// remove extra spaces from code
			$html = preg_replace('/[\s]+<\/(table|tr|td|th|ul|ol|li|dl|dt|dd)>/', '', $html);
			$html = preg_replace('/[\s]+<(tr|td|th|ul|ol|li|dl|dt|dd|br)/', '<\\1', $html);
			$html = preg_replace('/<\/(table|tr|td|th|blockquote|dd|dt|dl|div|dt|h1|h2|h3|h4|h5|h6|hr|li|ol|ul|p)>[\s]+<', $html);
			$html = preg_replace('/<\/(td|th)>/', '', $html);
			$html = preg_replace('/<\/table>([\s]*)/', '
', $html);
			$html = preg_replace('/[\s]*]*)>/xi', '', $html);
			$html = preg_replace('/]*)>/xi', '', $html);
			// trim string
			$html = preg_replace('/^[\s]+/', '', $html);
			$html = preg_replace('/[\s]+$/', '', $html);
			// pattern for generic tag
			$tagpattern = '/(<[^>]+>)/';
			// explodes the string
			$a = preg_split($tagpattern, $html, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
			// count elements
			$maxel = count($a);
			$elkey = 0;
			$key = 0;
			// create an array of elements
			$dom = array();
			$dom[$key] = array();
			// set first void element
			$dom[$key]['tag'] = false;
			$dom[$key]['block'] = false;
			$dom[$key]['value'] = '';
			$dom[$key]['parent'] = 0;
			$dom[$key]['fontname'] = $this->FontFamily;
			$dom[$key]['fontstyle'] = $this->FontStyle;
			$dom[$key]['fontsize'] = $this->FontSizePt;
			$dom[$key]['stroke'] = $this->textstrokewidth;
			$dom[$key]['fill'] = (($this->textrendermode % 2) == 0);
			$dom[$key]['clip'] = ($this->textrendermode > 3);
			$dom[$key]['line-height'] = $this->cell_height_ratio;
			$dom[$key]['bgcolor'] = false;
			$dom[$key]['fgcolor'] = $this->fgcolor;
			$dom[$key]['strokecolor'] = $this->strokecolor;
			$dom[$key]['align'] = '';
			$dom[$key]['listtype'] = '';
			$dom[$key]['text-indent'] = 0;
			$thead = false; // true when we are inside the THEAD tag
			++$key;
			$level = array();
			array_push($level, 0); // root
			while ($elkey < $maxel) {
				$dom[$key] = array();
				$element = $a[$elkey];
				$dom[$key]['elkey'] = $elkey;
				if (preg_match($tagpattern, $element)) {
					// html tag
					$element = substr($element, 1, -1);
					// get tag name
					preg_match('/[\/]?([a-zA-Z0-9]*)/', $element, $tag);
					$tagname = strtolower($tag[1]);
					// check if we are inside a table header
					if ($tagname == 'thead') {
						if ($element{0} == '/') {
							$thead = false;
						} else {
							$thead = true;
						}
						++$elkey;
						continue;
					}
					$dom[$key]['tag'] = true;
					$dom[$key]['value'] = $tagname;
					if (in_array($dom[$key]['value'], $blocktags)) {
						$dom[$key]['block'] = true;
					} else {
						$dom[$key]['block'] = false;
					}
					if ($element{0} == '/') {
						// *** closing html tag
						$dom[$key]['opening'] = false;
						$dom[$key]['parent'] = end($level);
						array_pop($level);
						$dom[$key]['fontname'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['fontname'];
						$dom[$key]['fontstyle'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['fontstyle'];
						$dom[$key]['fontsize'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['fontsize'];
						$dom[$key]['stroke'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['stroke'];
						$dom[$key]['fill'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['fill'];
						$dom[$key]['clip'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['clip'];
						$dom[$key]['line-height'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['line-height'];
						$dom[$key]['bgcolor'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['bgcolor'];
						$dom[$key]['fgcolor'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['fgcolor'];
						$dom[$key]['strokecolor'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['strokecolor'];
						$dom[$key]['align'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['align'];
						if (isset($dom[($dom[($dom[$key]['parent'])]['parent'])]['listtype'])) {
							$dom[$key]['listtype'] = $dom[($dom[($dom[$key]['parent'])]['parent'])]['listtype'];
						}
						// set the number of columns in table tag
						if (($dom[$key]['value'] == 'tr') AND (!isset($dom[($dom[($dom[$key]['parent'])]['parent'])]['cols']))) {
							$dom[($dom[($dom[$key]['parent'])]['parent'])]['cols'] = $dom[($dom[$key]['parent'])]['cols'];
						}
						if (($dom[$key]['value'] == 'td') OR ($dom[$key]['value'] == 'th')) {
							$dom[($dom[$key]['parent'])]['content'] = '';
							for ($i = ($dom[$key]['parent'] + 1); $i < $key; ++$i) {
								$dom[($dom[$key]['parent'])]['content'] .= $a[$dom[$i]['elkey']];
							}
							$key = $i;
							// mark nested tables
							$dom[($dom[$key]['parent'])]['content'] = str_replace('', '', $dom[($dom[$key]['parent'])]['content']);
							$dom[($dom[$key]['parent'])]['content'] = str_replace('', '', $dom[($dom[$key]['parent'])]['content']);
						}
						// store header rows on a new table
						if (($dom[$key]['value'] == 'tr') AND ($dom[($dom[$key]['parent'])]['thead'] === true)) {
							if ($this->empty_string($dom[($dom[($dom[$key]['parent'])]['parent'])]['thead'])) {
								$dom[($dom[($dom[$key]['parent'])]['parent'])]['thead'] = $a[$dom[($dom[($dom[$key]['parent'])]['parent'])]['elkey']];
							}
							for ($i = $dom[$key]['parent']; $i <= $key; ++$i) {
								$dom[($dom[($dom[$key]['parent'])]['parent'])]['thead'] .= $a[$dom[$i]['elkey']];
							}
							if (!isset($dom[($dom[$key]['parent'])]['attribute'])) {
								$dom[($dom[$key]['parent'])]['attribute'] = array();
							}
							// header elements must be always contained in a single page
							$dom[($dom[$key]['parent'])]['attribute']['nobr'] = 'true';
						}
						if (($dom[$key]['value'] == 'table') AND (!$this->empty_string($dom[($dom[$key]['parent'])]['thead']))) {
							// remove the nobr attributes from the table header
							$dom[($dom[$key]['parent'])]['thead'] = str_replace(' nobr="true"', '', $dom[($dom[$key]['parent'])]['thead']);
							$dom[($dom[$key]['parent'])]['thead'] .= '';
						}
					} else {
						// *** opening html tag
						$dom[$key]['opening'] = true;
						$dom[$key]['parent'] = end($level);
						if (substr($element, -1, 1) != '/') {
							// not self-closing tag
							array_push($level, $key);
							$dom[$key]['self'] = false;
						} else {
							$dom[$key]['self'] = true;
						}
						// copy some values from parent
						$parentkey = 0;
						if ($key > 0) {
							$parentkey = $dom[$key]['parent'];
							$dom[$key]['fontname'] = $dom[$parentkey]['fontname'];
							$dom[$key]['fontstyle'] = $dom[$parentkey]['fontstyle'];
							$dom[$key]['fontsize'] = $dom[$parentkey]['fontsize'];
							$dom[$key]['stroke'] = $dom[$parentkey]['stroke'];
							$dom[$key]['fill'] = $dom[$parentkey]['fill'];
							$dom[$key]['clip'] = $dom[$parentkey]['clip'];
							$dom[$key]['line-height'] = $dom[$parentkey]['line-height'];
							$dom[$key]['bgcolor'] = $dom[$parentkey]['bgcolor'];
							$dom[$key]['fgcolor'] = $dom[$parentkey]['fgcolor'];
							$dom[$key]['strokecolor'] = $dom[$parentkey]['strokecolor'];
							$dom[$key]['align'] = $dom[$parentkey]['align'];
							$dom[$key]['listtype'] = $dom[$parentkey]['listtype'];
							$dom[$key]['text-indent'] = $dom[$parentkey]['text-indent'];
						}
						// get attributes
						preg_match_all('/([^=\s]*)=["]?([^"]*)["]?/', $element, $attr_array, PREG_PATTERN_ORDER);
						$dom[$key]['attribute'] = array(); // reset attribute array
						while (list($id, $name) = each($attr_array[1])) {
							$dom[$key]['attribute'][strtolower($name)] = $attr_array[2][$id];
						}
						// split style attributes
						if (isset($dom[$key]['attribute']['style'])) {
							// get style attributes
							preg_match_all('/([^;:\s]*):([^;]*)/', $dom[$key]['attribute']['style'], $style_array, PREG_PATTERN_ORDER);
							$dom[$key]['style'] = array(); // reset style attribute array
							while (list($id, $name) = each($style_array[1])) {
								$dom[$key]['style'][strtolower($name)] = trim($style_array[2][$id]);
							}
							// --- get some style attributes ---
							if (isset($dom[$key]['style']['font-family'])) {
								// font family
								if (isset($dom[$key]['style']['font-family'])) {
									$fontslist = preg_split('/[,]/', strtolower($dom[$key]['style']['font-family']));
									foreach ($fontslist as $font) {
										$font = trim(strtolower($font));
										if (in_array($font, $this->fontlist) OR in_array($font, $this->fontkeys)) {
											$dom[$key]['fontname'] = $font;
											break;
										}
									}
								}
							}
							// list-style-type
							if (isset($dom[$key]['style']['list-style-type'])) {
								$dom[$key]['listtype'] = trim(strtolower($dom[$key]['style']['list-style-type']));
								if ($dom[$key]['listtype'] == 'inherit') {
									$dom[$key]['listtype'] = $dom[$parentkey]['listtype'];
								}
							}
							// text-indent
							if (isset($dom[$key]['style']['text-indent'])) {
								$dom[$key]['text-indent'] = $this->getHTMLUnitToUnits($dom[$key]['style']['text-indent']);
								if ($dom[$key]['text-indent'] == 'inherit') {
									$dom[$key]['text-indent'] = $dom[$parentkey]['text-indent'];
								}
							}
							// font size
							if (isset($dom[$key]['style']['font-size'])) {
								$fsize = trim($dom[$key]['style']['font-size']);
								switch ($fsize) {
									// absolute-size
									case 'xx-small': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'] - 4;
										break;
									}
									case 'x-small': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'] - 3;
										break;
									}
									case 'small': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'] - 2;
										break;
									}
									case 'medium': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'];
										break;
									}
									case 'large': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'] + 2;
										break;
									}
									case 'x-large': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'] + 4;
										break;
									}
									case 'xx-large': {
										$dom[$key]['fontsize'] = $dom[0]['fontsize'] + 6;
										break;
									}
									// relative-size
									case 'smaller': {
										$dom[$key]['fontsize'] = $dom[$parentkey]['fontsize'] - 3;
										break;
									}
									case 'larger': {
										$dom[$key]['fontsize'] = $dom[$parentkey]['fontsize'] + 3;
										break;
									}
									default: {
										$dom[$key]['fontsize'] = $this->getHTMLUnitToUnits($fsize, $dom[$parentkey]['fontsize'], 'pt', true);
									}
								}
							}
							// line-height
							if (isset($dom[$key]['style']['line-height'])) {
								$lineheight = trim($dom[$key]['style']['line-height']);
								switch ($lineheight) {
									// A normal line height. This is default
									case 'normal': {
										$dom[$key]['line-height'] = $dom[0]['line-height'];
										break;
									}
									default: {
										if (is_numeric($lineheight)) {
											$lineheight = $lineheight * 100;
										}
										$dom[$key]['line-height'] = $this->getHTMLUnitToUnits($lineheight, 1, '%', true);
									}
								}
							}
							// font style
							if (isset($dom[$key]['style']['font-weight']) AND (strtolower($dom[$key]['style']['font-weight']{0}) == 'b')) {
								$dom[$key]['fontstyle'] .= 'B';
							}
							if (isset($dom[$key]['style']['font-style']) AND (strtolower($dom[$key]['style']['font-style']{0}) == 'i')) {
								$dom[$key]['fontstyle'] .= 'I';
							}
							// font color
							if (isset($dom[$key]['style']['color']) AND (!$this->empty_string($dom[$key]['style']['color']))) {
								$dom[$key]['fgcolor'] = $this->convertHTMLColorToDec($dom[$key]['style']['color']);
							}
							// background color
							if (isset($dom[$key]['style']['background-color']) AND (!$this->empty_string($dom[$key]['style']['background-color']))) {
								$dom[$key]['bgcolor'] = $this->convertHTMLColorToDec($dom[$key]['style']['background-color']);
							}
							// text-decoration
							if (isset($dom[$key]['style']['text-decoration'])) {
								$decors = explode(' ', strtolower($dom[$key]['style']['text-decoration']));
								foreach ($decors as $dec) {
									$dec = trim($dec);
									if (!$this->empty_string($dec)) {
										if ($dec{0} == 'u') {
											// underline
											$dom[$key]['fontstyle'] .= 'U';
										} elseif ($dec{0} == 'l') {
											// line-trough
											$dom[$key]['fontstyle'] .= 'D';
										} elseif ($dec{0} == 'o') {
											// overline
											$dom[$key]['fontstyle'] .= 'O';
										}
									}
								}
							}
							// check for width attribute
							if (isset($dom[$key]['style']['width'])) {
								$dom[$key]['width'] = $dom[$key]['style']['width'];
							}
							// check for height attribute
							if (isset($dom[$key]['style']['height'])) {
								$dom[$key]['height'] = $dom[$key]['style']['height'];
							}
							// check for text alignment
							if (isset($dom[$key]['style']['text-align'])) {
								$dom[$key]['align'] = strtoupper($dom[$key]['style']['text-align']{0});
							}
							// check for border attribute
							if (isset($dom[$key]['style']['border'])) {
								$dom[$key]['attribute']['border'] = $dom[$key]['style']['border'];
							}
							// page-break-inside
							if (isset($dom[$key]['style']['page-break-inside']) AND ($dom[$key]['style']['page-break-inside'] == 'avoid')) {
								$dom[$key]['attribute']['nobr'] = 'true';
							}
							// page-break-before
							if (isset($dom[$key]['style']['page-break-before'])) {
								if ($dom[$key]['style']['page-break-before'] == 'always') {
									$dom[$key]['attribute']['pagebreak'] = 'true';
								} elseif ($dom[$key]['style']['page-break-before'] == 'left') {
									$dom[$key]['attribute']['pagebreak'] = 'left';
								} elseif ($dom[$key]['style']['page-break-before'] == 'right') {
									$dom[$key]['attribute']['pagebreak'] = 'right';
								}
							}
							// page-break-after
							if (isset($dom[$key]['style']['page-break-after'])) {
								if ($dom[$key]['style']['page-break-after'] == 'always') {
									$dom[$key]['attribute']['pagebreakafter'] = 'true';
								} elseif ($dom[$key]['style']['page-break-after'] == 'left') {
									$dom[$key]['attribute']['pagebreakafter'] = 'left';
								} elseif ($dom[$key]['style']['page-break-after'] == 'right') {
									$dom[$key]['attribute']['pagebreakafter'] = 'right';
								}
							}
						}
						// check for font tag
						if ($dom[$key]['value'] == 'font') {
							// font family
							if (isset($dom[$key]['attribute']['face'])) {
								$fontslist = preg_split('/[,]/', strtolower($dom[$key]['attribute']['face']));
								foreach ($fontslist as $font) {
									$font = trim(strtolower($font));
									if (in_array($font, $this->fontlist) OR in_array($font, $this->fontkeys)) {
										$dom[$key]['fontname'] = $font;
										break;
									}
								}
							}
							// font size
							if (isset($dom[$key]['attribute']['size'])) {
								if ($key > 0) {
									if ($dom[$key]['attribute']['size']{0} == '+') {
										$dom[$key]['fontsize'] = $dom[($dom[$key]['parent'])]['fontsize'] + intval(substr($dom[$key]['attribute']['size'], 1));
									} elseif ($dom[$key]['attribute']['size']{0} == '-') {
										$dom[$key]['fontsize'] = $dom[($dom[$key]['parent'])]['fontsize'] - intval(substr($dom[$key]['attribute']['size'], 1));
									} else {
										$dom[$key]['fontsize'] = intval($dom[$key]['attribute']['size']);
									}
								} else {
									$dom[$key]['fontsize'] = intval($dom[$key]['attribute']['size']);
								}
							}
						}
						// force natural alignment for lists
						if ((($dom[$key]['value'] == 'ul') OR ($dom[$key]['value'] == 'ol') OR ($dom[$key]['value'] == 'dl'))
							AND (!isset($dom[$key]['align']) OR $this->empty_string($dom[$key]['align']) OR ($dom[$key]['align'] != 'J'))) {
							if ($this->rtl) {
								$dom[$key]['align'] = 'R';
							} else {
								$dom[$key]['align'] = 'L';
							}
						}
						if (($dom[$key]['value'] == 'small') OR ($dom[$key]['value'] == 'sup') OR ($dom[$key]['value'] == 'sub')) {
							$dom[$key]['fontsize'] = $dom[$key]['fontsize'] * K_SMALL_RATIO;
						}
						if (($dom[$key]['value'] == 'strong') OR ($dom[$key]['value'] == 'b')) {
							$dom[$key]['fontstyle'] .= 'B';
						}
						if (($dom[$key]['value'] == 'em') OR ($dom[$key]['value'] == 'i')) {
							$dom[$key]['fontstyle'] .= 'I';
						}
						if ($dom[$key]['value'] == 'u') {
							$dom[$key]['fontstyle'] .= 'U';
						}
						if ($dom[$key]['value'] == 'del') {
							$dom[$key]['fontstyle'] .= 'D';
						}
						if (($dom[$key]['value'] == 'pre') OR ($dom[$key]['value'] == 'tt')) {
							$dom[$key]['fontname'] = $this->default_monospaced_font;
						}
						if (($dom[$key]['value']{0} == 'h') AND (intval($dom[$key]['value']{1}) > 0) AND (intval($dom[$key]['value']{1}) < 7)) {
							$headsize = (4 - intval($dom[$key]['value']{1})) * 2;
							$dom[$key]['fontsize'] = $dom[0]['fontsize'] + $headsize;
							$dom[$key]['fontstyle'] .= 'B';
						}
						if (($dom[$key]['value'] == 'table')) {
							$dom[$key]['rows'] = 0; // number of rows
							$dom[$key]['trids'] = array(); // IDs of TR elements
							$dom[$key]['thead'] = ''; // table header rows
						}
						if (($dom[$key]['value'] == 'tr')) {
							$dom[$key]['cols'] = 0;
							if ($thead) {
								$dom[$key]['thead'] = true;
								// rows on thead block are printed as a separate table
							} else {
								$dom[$key]['thead'] = false;
								// store the number of rows on table element
								++$dom[($dom[$key]['parent'])]['rows'];
								// store the TR elements IDs on table element
								array_push($dom[($dom[$key]['parent'])]['trids'], $key);
							}
						}
						if (($dom[$key]['value'] == 'th') OR ($dom[$key]['value'] == 'td')) {
							if (isset($dom[$key]['attribute']['colspan'])) {
								$colspan = intval($dom[$key]['attribute']['colspan']);
							} else {
								$colspan = 1;
							}
							$dom[$key]['attribute']['colspan'] = $colspan;
							$dom[($dom[$key]['parent'])]['cols'] += $colspan;
						}
						// set foreground color attribute
						if (isset($dom[$key]['attribute']['color']) AND (!$this->empty_string($dom[$key]['attribute']['color']))) {
							$dom[$key]['fgcolor'] = $this->convertHTMLColorToDec($dom[$key]['attribute']['color']);
						}
						// set background color attribute
						if (isset($dom[$key]['attribute']['bgcolor']) AND (!$this->empty_string($dom[$key]['attribute']['bgcolor']))) {
							$dom[$key]['bgcolor'] = $this->convertHTMLColorToDec($dom[$key]['attribute']['bgcolor']);
						}
						// set stroke color attribute
						if (isset($dom[$key]['attribute']['strokecolor']) AND (!$this->empty_string($dom[$key]['attribute']['strokecolor']))) {
							$dom[$key]['strokecolor'] = $this->convertHTMLColorToDec($dom[$key]['attribute']['strokecolor']);
						}
						// check for width attribute
						if (isset($dom[$key]['attribute']['width'])) {
							$dom[$key]['width'] = $dom[$key]['attribute']['width'];
						}
						// check for height attribute
						if (isset($dom[$key]['attribute']['height'])) {
							$dom[$key]['height'] = $dom[$key]['attribute']['height'];
						}
						// check for text alignment
						if (isset($dom[$key]['attribute']['align']) AND (!$this->empty_string($dom[$key]['attribute']['align'])) AND ($dom[$key]['value'] !== 'img')) {
							$dom[$key]['align'] = strtoupper($dom[$key]['attribute']['align']{0});
						}
						// check for text rendering mode (the following attributes do not exist in HTML)
						if (isset($dom[$key]['attribute']['stroke'])) {
							// font stroke width
							$dom[$key]['stroke'] = $this->getHTMLUnitToUnits($dom[$key]['attribute']['stroke'], $dom[$key]['fontsize'], 'pt', true);
						}
						if (isset($dom[$key]['attribute']['fill'])) {
							// font fill
							if ($dom[$key]['attribute']['fill'] == 'true') {
								$dom[$key]['fill'] = true;
							} else {
								$dom[$key]['fill'] = false;
							}
						}
						if (isset($dom[$key]['attribute']['clip'])) {
							// clipping mode
							if ($dom[$key]['attribute']['clip'] == 'true') {
								$dom[$key]['clip'] = true;
							} else {
								$dom[$key]['clip'] = false;
							}
						}
					} // end opening tag
				} else {
					// text
					$dom[$key]['tag'] = false;
					$dom[$key]['block'] = false;
					$dom[$key]['value'] = stripslashes($this->unhtmlentities($element));
					$dom[$key]['parent'] = end($level);
				}
				++$elkey;
				++$key;
			}
			return $dom;
		}

		/**
		 * Returns the string used to find spaces
		 * @return string
		 * @access protected
		 * @author Nicola Asuni
		 * @since 4.8.024 (2010-01-15)
		 */
		protected function getSpaceString() {
			$spacestr = chr(32);
			if (($this->CurrentFont['type'] == 'TrueTypeUnicode') OR ($this->CurrentFont['type'] == 'cidfont0')) {
				$spacestr = chr(0).chr(32);
			}
			return $spacestr;
		}

		/**
		 * Allows to preserve some HTML formatting (limited support).

		 * IMPORTANT: The HTML must be well formatted - try to clean-up it using an application like HTML-Tidy before submitting.
		 * Supported tags are: a, b, blockquote, br, dd, del, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, img, li, ol, p, pre, small, span, strong, sub, sup, table, tcpdf, td, th, thead, tr, tt, u, ul
		 * @param string $html text to display
		 * @param boolean $ln if true add a new line after text (default = true)
		 * @param int $fill Indicates if the background must be painted (true) or transparent (false).
		 * @param boolean $reseth if true reset the last cell height (default false).
		 * @param boolean $cell if true add the default cMargin space to each Write (default false).
		 * @param string $align Allows to center or align the text. Possible values are:
L : left align
C : center
R : right align
'' : empty string : left for LTR or right for RTL
		 * @access public
		 */
		public function writeHTML($html, $ln=true, $fill=false, $reseth=false, $cell=false, $align='') {
			$gvars = $this->getGraphicVars();
			// store current values
			$prevPage = $this->page;
			$prevlMargin = $this->lMargin;
			$prevrMargin = $this->rMargin;
			$curfontname = $this->FontFamily;
			$curfontstyle = $this->FontStyle;
			$curfontsize = $this->FontSizePt;
			$curfontascent = $this->getFontAscent($curfontname, $curfontstyle, $curfontsize);
			$curfontdescent = $this->getFontDescent($curfontname, $curfontstyle, $curfontsize);
			$this->newline = true;
			$startlinepage = $this->page;
			$minstartliney = $this->y;
			$maxbottomliney = 0;
			$startlinex = $this->x;
			$startliney = $this->y;
			$yshift = 0;
			$newline = true;
			$loop = 0;
			$curpos = 0;
			$this_method_vars = array();
			$undo = false;
			$fontaligned = false;
			$this->premode = false;
			if (isset($this->PageAnnots[$this->page])) {
				$pask = count($this->PageAnnots[$this->page]);
			} else {
				$pask = 0;
			}
			if (!$this->InFooter) {
				if (isset($this->footerlen[$this->page])) {
					$this->footerpos[$this->page] = $this->pagelen[$this->page] - $this->footerlen[$this->page];
				} else {
					$this->footerpos[$this->page] = $this->pagelen[$this->page];
				}
				$startlinepos = $this->footerpos[$this->page];
			} else {
				$startlinepos = $this->pagelen[$this->page];
			}
			$lalign = $align;
			$plalign = $align;
			if ($this->rtl) {
				$w = $this->x - $this->lMargin;
			} else {
				$w = $this->w - $this->rMargin - $this->x;
			}
			$w -= (2 * $this->cMargin);
			if ($cell) {
				if ($this->rtl) {
					$this->x -= $this->cMargin;
				} else {
					$this->x += $this->cMargin;
				}
			}
			if ($this->customlistindent >= 0) {
				$this->listindent = $this->customlistindent;
			} else {
				$this->listindent = $this->GetStringWidth('0000');
			}
			$this->listindentlevel = 0;
			// save previous states
			$prev_cell_height_ratio = $this->cell_height_ratio;
			$prev_listnum = $this->listnum;
			$prev_listordered = $this->listordered;
			$prev_listcount = $this->listcount;
			$prev_lispacer = $this->lispacer;
			$this->listnum = 0;
			$this->listordered = array();
			$this->listcount = array();
			$this->lispacer = '';
			if (($this->empty_string($this->lasth)) OR ($reseth)) {
				//set row height
				$this->lasth = $this->FontSize * $this->cell_height_ratio;
			}
			$dom = $this->getHtmlDomArray($html);
			$maxel = count($dom);
			$key = 0;
			while ($key < $maxel) {
				if ($dom[$key]['tag'] AND isset($dom[$key]['attribute']['pagebreak'])) {
					// check for pagebreak
					if (($dom[$key]['attribute']['pagebreak'] == 'true') OR ($dom[$key]['attribute']['pagebreak'] == 'left') OR ($dom[$key]['attribute']['pagebreak'] == 'right')) {
						// add a page (or trig AcceptPageBreak() for multicolumn mode)
						$this->checkPageBreak($this->PageBreakTrigger + 1);
					}
					if ((($dom[$key]['attribute']['pagebreak'] == 'left') AND (((!$this->rtl) AND (($this->page % 2) == 0)) OR (($this->rtl) AND (($this->page % 2) != 0))))
						OR (($dom[$key]['attribute']['pagebreak'] == 'right') AND (((!$this->rtl) AND (($this->page % 2) != 0)) OR (($this->rtl) AND (($this->page % 2) == 0))))) {
						// add a page (or trig AcceptPageBreak() for multicolumn mode)
						$this->checkPageBreak($this->PageBreakTrigger + 1);
					}
				}
				if ($dom[$key]['tag'] AND $dom[$key]['opening'] AND isset($dom[$key]['attribute']['nobr']) AND ($dom[$key]['attribute']['nobr'] == 'true')) {
					if (isset($dom[($dom[$key]['parent'])]['attribute']['nobr']) AND ($dom[($dom[$key]['parent'])]['attribute']['nobr'] == 'true')) {
						$dom[$key]['attribute']['nobr'] = false;
					} else {
						// store current object
						$this->startTransaction();
						// save this method vars
						$this_method_vars['html'] = $html;
						$this_method_vars['ln'] = $ln;
						$this_method_vars['fill'] = $fill;
						$this_method_vars['reseth'] = $reseth;
						$this_method_vars['cell'] = $cell;
						$this_method_vars['align'] = $align;
						$this_method_vars['gvars'] = $gvars;
						$this_method_vars['prevPage'] = $prevPage;
						$this_method_vars['prevlMargin'] = $prevlMargin;
						$this_method_vars['prevrMargin'] = $prevrMargin;
						$this_method_vars['curfontname'] = $curfontname;
						$this_method_vars['curfontstyle'] = $curfontstyle;
						$this_method_vars['curfontsize'] = $curfontsize;
						$this_method_vars['curfontascent'] = $curfontascent;
						$this_method_vars['curfontdescent'] = $curfontdescent;
						$this_method_vars['minstartliney'] = $minstartliney;
						$this_method_vars['maxbottomliney'] = $maxbottomliney;
						$this_method_vars['yshift'] = $yshift;
						$this_method_vars['startlinepage'] = $startlinepage;
						$this_method_vars['startlinepos'] = $startlinepos;
						$this_method_vars['startlinex'] = $startlinex;
						$this_method_vars['startliney'] = $startliney;
						$this_method_vars['newline'] = $newline;
						$this_method_vars['loop'] = $loop;
						$this_method_vars['curpos'] = $curpos;
						$this_method_vars['pask'] = $pask;
						$this_method_vars['lalign'] = $lalign;
						$this_method_vars['plalign'] = $plalign;
						$this_method_vars['w'] = $w;
						$this_method_vars['prev_cell_height_ratio'] = $prev_cell_height_ratio;
						$this_method_vars['prev_listnum'] = $prev_listnum;
						$this_method_vars['prev_listordered'] = $prev_listordered;
						$this_method_vars['prev_listcount'] = $prev_listcount;
						$this_method_vars['prev_lispacer'] = $prev_lispacer;
						$this_method_vars['fontaligned'] = $fontaligned;
						$this_method_vars['key'] = $key;
						$this_method_vars['dom'] = $dom;
					}
				}
				// print THEAD block
				if (($dom[$key]['value'] == 'tr') AND isset($dom[$key]['thead']) AND $dom[$key]['thead']) {
					if (isset($dom[$key]['parent']) AND isset($dom[$dom[$key]['parent']]['thead']) AND !$this->empty_string($dom[$dom[$key]['parent']]['thead'])) {
						$this->inthead = true;
						// print table header (thead)
						$this->writeHTML($this->thead, false, false, false, false, '');
						if (($this->start_transaction_page == ($this->numpages - 1)) OR ($this->y < $this->start_transaction_y) OR ($this->checkPageBreak($this->lasth, '', false))) {
							// restore previous object
							$this->rollbackTransaction(true);
							// restore previous values
							foreach ($this_method_vars as $vkey => $vval) {
								$$vkey = $vval;
							}
							// add a page (or trig AcceptPageBreak() for multicolumn mode)
							$pre_y = $this->y;
							if ((!$this->checkPageBreak($this->PageBreakTrigger + 1)) AND ($this->y < $pre_y)) {
								// fix for multicolumn mode
								$startliney = $this->y;
							}
							$this->start_transaction_page = $this->page;
							$this->start_transaction_y = $this->y;
						}
					}
					// move $key index forward to skip THEAD block
					while ( ($key < $maxel) AND (!(
						($dom[$key]['tag'] AND $dom[$key]['opening'] AND ($dom[$key]['value'] == 'tr') AND (!isset($dom[$key]['thead']) OR !$dom[$key]['thead']))
						OR ($dom[$key]['tag'] AND (!$dom[$key]['opening']) AND ($dom[$key]['value'] == 'table'))) )) {
						++$key;
					}
				}
				if ($dom[$key]['tag'] OR ($key == 0)) {
					if (isset($dom[$key]['line-height'])) {
						// set line height
						$this->cell_height_ratio = $dom[$key]['line-height'];
						$this->lasth = $this->FontSize * $this->cell_height_ratio;
					}
					if ((($dom[$key]['value'] == 'table') OR ($dom[$key]['value'] == 'tr')) AND (isset($dom[$key]['align']))) {
						$dom[$key]['align'] = ($this->rtl) ? 'R' : 'L';
					}
					// vertically align image in line
					if ((!$this->newline) AND ($dom[$key]['value'] == 'img') AND (isset($dom[$key]['attribute']['height'])) AND ($dom[$key]['attribute']['height'] > 0)) {
						// get image height
						$imgh = $this->getHTMLUnitToUnits($dom[$key]['attribute']['height'], $this->lasth, 'px');
						// check for automatic line break
						$autolinebreak = false;
						if (isset($dom[$key]['attribute']['width']) AND ($dom[$key]['attribute']['width'] > 0)) {
							$imgw = $this->getHTMLUnitToUnits($dom[$key]['attribute']['width'], 1, 'px', false);
							if (($this->rtl AND (($this->x - $imgw) < ($this->lMargin + $this->cMargin)))
								OR (!$this->rtl AND (($this->x + $imgw) > ($this->w - $this->rMargin - $this->cMargin)))) {
								// add automatic line break
								$autolinebreak = true;
								$this->Ln('', $cell);
								// go back to evaluate this line break
								--$key;
							}
						}
						if (!$autolinebreak) {
							if (!$this->InFooter) {
								$pre_y = $this->y;
								// check for page break
								if ((!$this->checkPageBreak($imgh)) AND ($this->y < $pre_y)) {
									// fix for multicolumn mode
									$startliney = $this->y;
								}
							}
							if ($this->page > $startlinepage) {
								// fix line splitted over two pages
								if (isset($this->footerlen[$startlinepage])) {
									$curpos = $this->pagelen[$startlinepage] - $this->footerlen[$startlinepage];
								}
								// line to be moved one page forward
								$pagebuff = $this->getPageBuffer($startlinepage);
								$linebeg = substr($pagebuff, $startlinepos, ($curpos - $startlinepos));
								$tstart = substr($pagebuff, 0, $startlinepos);
								$tend = substr($this->getPageBuffer($startlinepage), $curpos);
								// remove line from previous page
								$this->setPageBuffer($startlinepage, $tstart.''.$tend);
								$pagebuff = $this->getPageBuffer($this->page);
								$tstart = substr($pagebuff, 0, $this->cntmrk[$this->page]);
								$tend = substr($pagebuff, $this->cntmrk[$this->page]);
								// add line start to current page
								$yshift = $minstartliney - $this->y;
								if ($fontaligned) {
									$yshift += ($curfontsize / $this->k);
								}
								$try = sprintf('1 0 0 1 0 %.3F cm', ($yshift * $this->k));
								$this->setPageBuffer($this->page, $tstart."\nq\n".$try."\n".$linebeg."\nQ\n".$tend);
								// shift the annotations and links
								if (isset($this->PageAnnots[$this->page])) {
									$next_pask = count($this->PageAnnots[$this->page]);
								} else {
									$next_pask = 0;
								}
								if (isset($this->PageAnnots[$startlinepage])) {
									foreach ($this->PageAnnots[$startlinepage] as $pak => $pac) {
										if ($pak >= $pask) {
											$this->PageAnnots[$this->page][] = $pac;
											unset($this->PageAnnots[$startlinepage][$pak]);
											$npak = count($this->PageAnnots[$this->page]) - 1;
											$this->PageAnnots[$this->page][$npak]['y'] -= $yshift;
										}
									}
								}
								$pask = $next_pask;
								$startlinepos = $this->cntmrk[$this->page];
								$startlinepage = $this->page;
								$startliney = $this->y;
							}
							$this->y += ((($curfontsize * $this->cell_height_ratio / $this->k) + $curfontascent - $curfontdescent) / 2) - $imgh;
							$minstartliney = min($this->y, $minstartliney);
							$maxbottomliney = ($startliney + ($this->FontSize * $this->cell_height_ratio));
						}
					} elseif (isset($dom[$key]['fontname']) OR isset($dom[$key]['fontstyle']) OR isset($dom[$key]['fontsize'])) {
						// account for different font size
						$pfontname = $curfontname;
						$pfontstyle = $curfontstyle;
						$pfontsize = $curfontsize;
						$fontname = isset($dom[$key]['fontname']) ? $dom[$key]['fontname'] : $curfontname;
						$fontstyle = isset($dom[$key]['fontstyle']) ? $dom[$key]['fontstyle'] : $curfontstyle;
						$fontsize = isset($dom[$key]['fontsize']) ? $dom[$key]['fontsize'] : $curfontsize;
						$fontascent = $this->getFontAscent($fontname, $fontstyle, $fontsize);
						$fontdescent = $this->getFontDescent($fontname, $fontstyle, $fontsize);
						if (($fontname != $curfontname) OR ($fontstyle != $curfontstyle) OR ($fontsize != $curfontsize)) {
							if (is_numeric($fontsize) AND ($fontsize >= 0)
								AND is_numeric($curfontsize) AND ($curfontsize >= 0)
								AND ($fontsize != $curfontsize) AND (!$this->newline)
								AND ($key < ($maxel - 1))
								) {
								if ((!$this->newline) AND ($this->page > $startlinepage)) {
									// fix lines splitted over two pages
									if (isset($this->footerlen[$startlinepage])) {
										$curpos = $this->pagelen[$startlinepage] - $this->footerlen[$startlinepage];
									}
									// line to be moved one page forward
									$pagebuff = $this->getPageBuffer($startlinepage);
									$linebeg = substr($pagebuff, $startlinepos, ($curpos - $startlinepos));
									$tstart = substr($pagebuff, 0, $startlinepos);
									$tend = substr($this->getPageBuffer($startlinepage), $curpos);
									// remove line start from previous page
									$this->setPageBuffer($startlinepage, $tstart.''.$tend);
									$pagebuff = $this->getPageBuffer($this->page);
									$tstart = substr($pagebuff, 0, $this->cntmrk[$this->page]);
									$tend = substr($pagebuff, $this->cntmrk[$this->page]);
									// add line start to current page
									$yshift = $minstartliney - $this->y;
									$try = sprintf('1 0 0 1 0 %.3F cm', ($yshift * $this->k));
									$this->setPageBuffer($this->page, $tstart."\nq\n".$try."\n".$linebeg."\nQ\n".$tend);
									// shift the annotations and links
									if (isset($this->PageAnnots[$this->page])) {
										$next_pask = count($this->PageAnnots[$this->page]);
									} else {
										$next_pask = 0;
									}
									if (isset($this->PageAnnots[$startlinepage])) {
										foreach ($this->PageAnnots[$startlinepage] as $pak => $pac) {
											if ($pak >= $pask) {
												$this->PageAnnots[$this->page][] = $pac;
												unset($this->PageAnnots[$startlinepage][$pak]);
												$npak = count($this->PageAnnots[$this->page]) - 1;
												$this->PageAnnots[$this->page][$npak]['y'] -= $yshift;
											}
										}
									}
									$pask = $next_pask;
									$startlinepos = $this->cntmrk[$this->page];
									$startlinepage = $this->page;
									$startliney = $this->y;
								}
								if (!$dom[$key]['block']) {
									$this->y += ((($curfontsize - $fontsize) * $this->cell_height_ratio / $this->k) + $curfontascent - $fontascent - $curfontdescent + $fontdescent) / 2;
									if (($dom[$key]['value'] != 'sup') AND ($dom[$key]['value'] != 'sub')) {
										$minstartliney = min($this->y, $minstartliney);
										$maxbottomliney = max(($this->y + (($fontsize * $this->cell_height_ratio) / $this->k)), $maxbottomliney);
									}
								}
								$fontaligned = true;
							}
							$this->SetFont($fontname, $fontstyle, $fontsize);
							$this->lasth = $this->FontSize * $this->cell_height_ratio;
							$curfontname = $fontname;
							$curfontstyle = $fontstyle;
							$curfontsize = $fontsize;
							$curfontascent = $fontascent;
							$curfontdescent = $fontdescent;
						}
					}
					// set text rendering mode
					$textstroke = isset($dom[$key]['stroke']) ? $dom[$key]['stroke'] : $this->textstrokewidth;
					$textfill = isset($dom[$key]['fill']) ? $dom[$key]['fill'] : (($this->textrendermode % 2) == 0);
					$textclip = isset($dom[$key]['clip']) ? $dom[$key]['clip'] : ($this->textrendermode > 3);
					$this->setTextRenderingMode($textstroke, $textfill, $textclip);
					if (($plalign == 'J') AND $dom[$key]['block']) {
						$plalign = '';
					}
					// get current position on page buffer
					$curpos = $this->pagelen[$startlinepage];
					if (isset($dom[$key]['bgcolor']) AND ($dom[$key]['bgcolor'] !== false)) {
						$this->SetFillColorArray($dom[$key]['bgcolor']);
						$wfill = true;
					} else {
						$wfill = $fill | false;
					}
					if (isset($dom[$key]['fgcolor']) AND ($dom[$key]['fgcolor'] !== false)) {
						$this->SetTextColorArray($dom[$key]['fgcolor']);
					}
					if (isset($dom[$key]['strokecolor']) AND ($dom[$key]['strokecolor'] !== false)) {
						$this->SetDrawColorArray($dom[$key]['strokecolor']);
					}
					if (isset($dom[$key]['align'])) {
						$lalign = $dom[$key]['align'];
					}
					if ($this->empty_string($lalign)) {
						$lalign = $align;
					}
				}
				// align lines
				if ($this->newline AND (strlen($dom[$key]['value']) > 0) AND ($dom[$key]['value'] != 'td') AND ($dom[$key]['value'] != 'th')) {
					$newline = true;
					$fontaligned = false;
					// we are at the beginning of a new line
					if (isset($startlinex)) {
						$yshift = $minstartliney - $startliney;
						if (($yshift > 0) OR ($this->page > $startlinepage)) {
							$yshift = 0;
						}
						$t_x = 0;
						// the last line must be shifted to be aligned as requested
						$linew = abs($this->endlinex - $startlinex);
						$pstart = substr($this->getPageBuffer($startlinepage), 0, $startlinepos);
						if (isset($opentagpos) AND isset($this->footerlen[$startlinepage]) AND (!$this->InFooter)) {
							$this->footerpos[$startlinepage] = $this->pagelen[$startlinepage] - $this->footerlen[$startlinepage];
							$midpos = min($opentagpos, $this->footerpos[$startlinepage]);
						} elseif (isset($opentagpos)) {
							$midpos = $opentagpos;
						} elseif (isset($this->footerlen[$startlinepage]) AND (!$this->InFooter)) {
							$this->footerpos[$startlinepage] = $this->pagelen[$startlinepage] - $this->footerlen[$startlinepage];
							$midpos = $this->footerpos[$startlinepage];
						} else {
							$midpos = 0;
						}
						if ($midpos > 0) {
							$pmid = substr($this->getPageBuffer($startlinepage), $startlinepos, ($midpos - $startlinepos));
							$pend = substr($this->getPageBuffer($startlinepage), $midpos);
						} else {
							$pmid = substr($this->getPageBuffer($startlinepage), $startlinepos);
							$pend = '';
						}
						if ((isset($plalign) AND ((($plalign == 'C') OR ($plalign == 'J') OR (($plalign == 'R') AND (!$this->rtl)) OR (($plalign == 'L') AND ($this->rtl))))) OR ($yshift < 0)) {
							// calculate shifting amount
							$tw = $w;
							if (($plalign == 'J') AND $this->isRTLTextDir() AND ($this->num_columns > 1)) {
								$tw += $this->cMargin;
							}
							if ($this->lMargin != $prevlMargin) {
								$tw += ($prevlMargin - $this->lMargin);
							}
							if ($this->rMargin != $prevrMargin) {
								$tw += ($prevrMargin - $this->rMargin);
							}
							$one_space_width = $this->GetStringWidth(chr(32));
							$mdiff = abs($tw - $linew);
							if ($plalign == 'C') {
								if ($this->rtl) {
									$t_x = -($mdiff / 2);
								} else {
									$t_x = ($mdiff / 2);
								}
							} elseif (($plalign == 'R') AND (!$this->rtl)) {
								// right alignment on LTR document
								if (intval($this->revstrpos($pmid, ')]')) == (intval($this->revstrpos($pmid, ' )]')) + 1)) {
									// remove last space (if any)
									$linew -= $one_space_width;
									$mdiff = abs($tw - $linew);
								}
								$t_x = $mdiff;
							} elseif (($plalign == 'L') AND ($this->rtl)) {
								// left alignment on RTL document
								if (($this->revstrpos($pmid, '[(') > 0) AND ((intval($this->revstrpos($pmid, '[( ')) == intval($this->revstrpos($pmid, '[('))) OR (intval($this->revstrpos($pmid, '[('.chr(0).chr(32))) == intval($this->revstrpos($pmid, '[('))))) {
									// remove first space (if any)
									$linew -= $one_space_width;
								}
								if ((strpos($pmid, '[(') > 0) AND (intval(strpos($pmid, '[(')) == (intval($this->revstrpos($pmid, '[('))))) {
									// remove last space (if any)
									$linew -= $one_space_width;
									if (($this->CurrentFont['type'] == 'TrueTypeUnicode') OR ($this->CurrentFont['type'] == 'cidfont0')) {
										$linew -= $one_space_width;
									}
								}
								$mdiff = abs($tw - $linew);
								$t_x = -$mdiff;
							} elseif (($plalign == 'J') AND ($plalign == $lalign)) {
								// Justification
								if ($this->isRTLTextDir()) {
									$t_x = $this->lMargin - $this->endlinex + $this->cMargin;
								}
								$no = 0; // spaces without trim
								$ns = 0; // spaces with trim
								$pmidtemp = $pmid;
								// escape special characters
								$pmidtemp = preg_replace('/[\\\][\(]/x', '\\#!#OP#!#', $pmidtemp);
								$pmidtemp = preg_replace('/[\\\][\)]/x', '\\#!#CP#!#', $pmidtemp);
								// search spaces
								if (preg_match_all('/\[\(([^\)]*)\)\]/x', $pmidtemp, $lnstring, PREG_PATTERN_ORDER)) {
									$spacestr = $this->getSpaceString();
									$maxkk = count($lnstring[1]) - 1;
									for ($kk=0; $kk <= $maxkk; ++$kk) {
										// restore special characters
										$lnstring[1][$kk] = str_replace('#!#OP#!#', '(', $lnstring[1][$kk]);
										$lnstring[1][$kk] = str_replace('#!#CP#!#', ')', $lnstring[1][$kk]);
										if ($kk == $maxkk) {
											if ($this->isRTLTextDir()) {
												$tvalue = ltrim($lnstring[1][$kk]);
											} else {
												$tvalue = rtrim($lnstring[1][$kk]);
											}
										} else {
											$tvalue = $lnstring[1][$kk];
										}
										// store number of spaces on the strings
										$lnstring[2][$kk] = substr_count($lnstring[1][$kk], $spacestr);
										$lnstring[3][$kk] = substr_count($tvalue, $spacestr);
										// count total spaces on line
										$no += $lnstring[2][$kk];
										$ns += $lnstring[3][$kk];
										$lnstring[4][$kk] = $no;
										$lnstring[5][$kk] = $ns;
									}
									if ($this->isRTLTextDir()) {
										$t_x = $this->lMargin - $this->endlinex + $this->cMargin - (($no - $ns) * $one_space_width);
									}
									// calculate additional space to add to each space
									$spacelen = $one_space_width;
									$spacewidth = ((($tw - $linew) + (($no - $ns) * $spacelen)) / ($ns?$ns:1)) * $this->k;
									$spacewidthu = -1000 * (($tw - $linew) + ($no * $spacelen)) / ($ns?$ns:1) / $this->FontSize;
									$nsmax = $ns;
									$ns = 0;
									reset($lnstring);
									$offset = 0;
									$strcount = 0;
									$prev_epsposbeg = 0;
									$textpos = 0;
									if ($this->isRTLTextDir()) {
										$textpos = $this->wPt;
									}
									global $spacew;
									while (preg_match('/([0-9\.\+\-]*)[\s](Td|cm|m|l|c|re)[\s]/x', $pmid, $strpiece, PREG_OFFSET_CAPTURE, $offset) == 1) {
										// check if we are inside a string section '[( ... )]'
										$stroffset = strpos($pmid, '[(', $offset);
										if (($stroffset !== false) AND ($stroffset <= $strpiece[2][1])) {
											// set offset to the end of string section
											$offset = strpos($pmid, ')]', $stroffset);
											while (($offset !== false) AND ($pmid{($offset - 1)} == '\\')) {
												$offset = strpos($pmid, ')]', ($offset + 1));
											}
											if ($offset === false) {
												$this->Error('HTML Justification: malformed PDF code.');
											}
											continue;
										}
										if ($this->isRTLTextDir()) {
											$spacew = ($spacewidth * ($nsmax - $ns));
										} else {
											$spacew = ($spacewidth * $ns);
										}
										$offset = $strpiece[2][1] + strlen($strpiece[2][0]);
										$epsposbeg = strpos($pmid, 'q'.$this->epsmarker, $offset);
										$epsposend = strpos($pmid, $this->epsmarker.'Q', $offset) + strlen($this->epsmarker.'Q');
										if ((($epsposbeg > 0) AND ($epsposend > 0) AND ($offset > $epsposbeg) AND ($offset < $epsposend))
											OR (($epsposbeg === false) AND ($epsposend > 0) AND ($offset < $epsposend))) {
											// shift EPS images
											$trx = sprintf('1 0 0 1 %.3F 0 cm', $spacew);
											$epsposbeg = strpos($pmid, 'q'.$this->epsmarker, ($prev_epsposbeg - 6));
											$pmid_b = substr($pmid, 0, $epsposbeg);
											$pmid_m = substr($pmid, $epsposbeg, ($epsposend - $epsposbeg));
											$pmid_e = substr($pmid, $epsposend);
											$pmid = $pmid_b."\nq\n".$trx."\n".$pmid_m."\nQ\n".$pmid_e;
											$offset = $epsposend;
											continue;

										}
										$prev_epsposbeg = $epsposbeg;
										$currentxpos = 0;
										// shift blocks of code
										switch ($strpiece[2][0]) {
											case 'Td':
											case 'cm':
											case 'm':
											case 'l': {
												// get current X position
												preg_match('/([0-9\.\+\-]*)[\s]('.$strpiece[1][0].')[\s]('.$strpiece[2][0].')([\s]*)/x', $pmid, $xmatches);
												$currentxpos = $xmatches[1];
												$textpos = $currentxpos;
												if (($strcount <= $maxkk) AND ($strpiece[2][0] == 'Td')) {
													if ($strcount == $maxkk) {
														if ($this->isRTLTextDir()) {
															$tvalue = $lnstring[1][$strcount];
														} else {
															$tvalue = rtrim($lnstring[1][$strcount]);
														}
													} else {
														$tvalue = $lnstring[1][$strcount];
													}
													$ns += substr_count($tvalue, $spacestr);
													++$strcount;
												}
												if ($this->isRTLTextDir()) {
													$spacew = ($spacewidth * ($nsmax - $ns));
												}
												// justify block
												$pmid = preg_replace_callback('/([0-9\.\+\-]*)[\s]('.$strpiece[1][0].')[\s]('.$strpiece[2][0].')([\s]*)/x',
													create_function('$matches', 'global $spacew;
													$newx = sprintf("%.2F",(floatval($matches[1]) + $spacew));
													return "".$newx." ".$matches[2]." x*#!#*x".$matches[3].$matches[4];'), $pmid, 1);
												break;
											}
											case 're': {
												// justify block
												preg_match('/([0-9\.\+\-]*)[\s]([0-9\.\+\-]*)[\s]([0-9\.\+\-]*)[\s]('.$strpiece[1][0].')[\s](re)([\s]*)/x', $pmid, $xmatches);
												$currentxpos = $xmatches[1];
												global $x_diff, $w_diff;
												$x_diff = 0;
												$w_diff = 0;
												if ($this->isRTLTextDir()) { // RTL
													if ($currentxpos < $textpos) {
														$x_diff = ($spacewidth * ($nsmax - $lnstring[5][$strcount]));
														$w_diff = ($spacewidth * $lnstring[3][$strcount]);
													} else {
														if ($strcount > 0) {
															$x_diff = ($spacewidth * ($nsmax - $lnstring[5][($strcount - 1)]));
															$w_diff = ($spacewidth * $lnstring[3][($strcount - 1)]);
														}
													}
												} else { // LTR
													if ($currentxpos > $textpos) {
														if ($strcount > 0) {
															$x_diff = ($spacewidth * $lnstring[4][($strcount - 1)]);
														}
														$w_diff = ($spacewidth * $lnstring[3][$strcount]);
													} else {
														if ($strcount > 1) {
															$x_diff = ($spacewidth * $lnstring[4][($strcount - 2)]);
														}
														if ($strcount > 0) {
															$w_diff = ($spacewidth * $lnstring[3][($strcount - 1)]);
														}
													}
												}
												$pmid = preg_replace_callback('/('.$xmatches[1].')[\s]('.$xmatches[2].')[\s]('.$xmatches[3].')[\s]('.$strpiece[1][0].')[\s](re)([\s]*)/x',
													create_function('$matches', 'global $x_diff, $w_diff;
													$newx = sprintf("%.2F",(floatval($matches[1]) + $x_diff));
													$neww = sprintf("%.2F",(floatval($matches[3]) + $w_diff));
													return "".$newx." ".$matches[2]." ".$neww." ".$matches[4]." x*#!#*x".$matches[5].$matches[6];'), $pmid, 1);
												break;
											}
											case 'c': {
												// get current X position
												preg_match('/([0-9\.\+\-]*)[\s]([0-9\.\+\-]*)[\s]([0-9\.\+\-]*)[\s]([0-9\.\+\-]*)[\s]([0-9\.\+\-]*)[\s]('.$strpiece[1][0].')[\s](c)([\s]*)/x', $pmid, $xmatches);
												$currentxpos = $xmatches[1];
												// justify block
												$pmid = preg_replace_callback('/('.$xmatches[1].')[\s]('.$xmatches[2].')[\s]('.$xmatches[3].')[\s]('.$xmatches[4].')[\s]('.$xmatches[5].')[\s]('.$strpiece[1][0].')[\s](c)([\s]*)/x',
													create_function('$matches', 'global $spacew;
													$newx1 = sprintf("%.3F",(floatval($matches[1]) + $spacew));
													$newx2 = sprintf("%.3F",(floatval($matches[3]) + $spacew));
													$newx3 = sprintf("%.3F",(floatval($matches[5]) + $spacew));
													return "".$newx1." ".$matches[2]." ".$newx2." ".$matches[4]." ".$newx3." ".$matches[6]." x*#!#*x".$matches[7].$matches[8];'), $pmid, 1);
												break;
											}
										}
										// shift the annotations and links
										if (isset($this->PageAnnots[$this->page])) {
											$cxpos = ($currentxpos / $this->k);
											$lmpos = ($this->lMargin + $this->cMargin + $this->feps);
											foreach ($this->PageAnnots[$this->page] as $pak => $pac) {
												if (($pac['y'] >= $minstartliney) AND (($pac['x'] * $this->k) >= ($currentxpos - $this->feps)) AND (($pac['x'] * $this->k) <= ($currentxpos + $this->feps))) {
													if ($cxpos > $lmpos) {
														$this->PageAnnots[$this->page][$pak]['x'] += (($spacew - $one_space_width) / $this->k);
														$this->PageAnnots[$this->page][$pak]['w'] += (($spacewidth * $pac['numspaces']) / $this->k);
													} else {
														$this->PageAnnots[$this->page][$pak]['w'] += ((($spacewidth * $pac['numspaces']) - $one_space_width) / $this->k);
													}
													break;
												}
											}
										}
									} // end of while
									// remove markers
									$pmid = str_replace('x*#!#*x', '', $pmid);
									if (($this->CurrentFont['type'] == 'TrueTypeUnicode') OR ($this->CurrentFont['type'] == 'cidfont0')) {
										// multibyte characters
										$spacew = $spacewidthu;
										$pmidtemp = $pmid;
										// escape special characters
										$pmidtemp = preg_replace('/[\\\][\(]/x', '\\#!#OP#!#', $pmidtemp);
										$pmidtemp = preg_replace('/[\\\][\)]/x', '\\#!#CP#!#', $pmidtemp);
										$pmid = preg_replace_callback("/\[\(([^\)]*)\)\]/x",
													create_function('$matches', 'global $spacew;
													$matches[1] = str_replace("#!#OP#!#", "(", $matches[1]);
													$matches[1] = str_replace("#!#CP#!#", ")", $matches[1]);
													return "[(".str_replace(chr(0).chr(32), ") ".sprintf("%.3F", $spacew)." (", $matches[1]).")]";'), $pmidtemp);
										$this->setPageBuffer($startlinepage, $pstart."\n".$pmid."\n".$pend);
										$endlinepos = strlen($pstart."\n".$pmid."\n");
									} else {
										// non-unicode (single-byte characters)
										$rs = sprintf('%.3F Tw', $spacewidth);
										$pmid = preg_replace("/\[\(/x", $rs.' [(', $pmid);
										$this->setPageBuffer($startlinepage, $pstart."\n".$pmid."\nBT 0 Tw ET\n".$pend);
										$endlinepos = strlen($pstart."\n".$pmid."\nBT 0 Tw ET\n");
									}
								}
							} // end of J
						} // end if $startlinex
						if (($t_x != 0) OR ($yshift < 0)) {
							// shift the line
							$trx = sprintf('1 0 0 1 %.3F %.3F cm', ($t_x * $this->k), ($yshift * $this->k));
							$this->setPageBuffer($startlinepage, $pstart."\nq\n".$trx."\n".$pmid."\nQ\n".$pend);
							$endlinepos = strlen($pstart."\nq\n".$trx."\n".$pmid."\nQ\n");
							// shift the annotations and links
							if (isset($this->PageAnnots[$this->page])) {
								foreach ($this->PageAnnots[$this->page] as $pak => $pac) {
									if ($pak >= $pask) {
										$this->PageAnnots[$this->page][$pak]['x'] += $t_x;
										$this->PageAnnots[$this->page][$pak]['y'] -= $yshift;
									}
								}
							}
							$this->y -= $yshift;
						}
					}
					$this->newline = false;
					$pbrk = $this->checkPageBreak($this->lasth);
					$startlinex = $this->x;
					$startliney = $this->y;
					$minstartliney = $startliney;
					$maxbottomliney = ($this->y + (($fontsize * $this->cell_height_ratio) / $this->k));
					$startlinepage = $this->page;
					if (isset($endlinepos) AND (!$pbrk)) {
						$startlinepos = $endlinepos;
					} else {
						if (!$this->InFooter) {
							if (isset($this->footerlen[$this->page])) {
								$this->footerpos[$this->page] = $this->pagelen[$this->page] - $this->footerlen[$this->page];
							} else {
								$this->footerpos[$this->page] = $this->pagelen[$this->page];
							}
							$startlinepos = $this->footerpos[$this->page];
						} else {
							$startlinepos = $this->pagelen[$this->page];
						}
					}
					unset($endlinepos);
					$plalign = $lalign;
					if (isset($this->PageAnnots[$this->page])) {
						$pask = count($this->PageAnnots[$this->page]);
					} else {
						$pask = 0;
					}
					$this->SetFont($fontname, $fontstyle, $fontsize);
					if ($wfill) {
						$this->SetFillColorArray($this->bgcolor);
					}
				} // end newline
				if (isset($opentagpos)) {
					unset($opentagpos);
				}
				if ($dom[$key]['tag']) {
					if ($dom[$key]['opening']) {
						// get text indentation (if any)
						if (isset($dom[$key]['text-indent']) AND $dom[$key]['block']) {
							$this->textindent = $dom[$key]['text-indent'];
							$this->newline = true;
						}
						if ($dom[$key]['value'] == 'table') {
							// available page width
							if ($this->rtl) {
								$wtmp = $this->x - $this->lMargin;
							} else {
								$wtmp = $this->w - $this->rMargin - $this->x;
							}
							if (isset($dom[$key]['attribute']['nested']) AND ($dom[$key]['attribute']['nested'] == 'true')) {
								// add margin for nested tables
								$wtmp -= $this->cMargin;
							}
							// table width
							if (isset($dom[$key]['width'])) {
								$table_width = $this->getHTMLUnitToUnits($dom[$key]['width'], $wtmp, 'px');
							} else {
								$table_width = $wtmp;
							}
						}
						if (($dom[$key]['value'] == 'td') OR ($dom[$key]['value'] == 'th')) {
							$trid = $dom[$key]['parent'];
							$table_el = $dom[$trid]['parent'];
							if (!isset($dom[$table_el]['cols'])) {
								$dom[$table_el]['cols'] = $dom[$trid]['cols'];
							}
							$oldmargin = $this->cMargin;
							if (isset($dom[($dom[$trid]['parent'])]['attribute']['cellpadding'])) {
								$currentcmargin = $this->getHTMLUnitToUnits($dom[($dom[$trid]['parent'])]['attribute']['cellpadding'], 1, 'px');
							} else {
								$currentcmargin = 0;
							}
							$this->cMargin = $currentcmargin;
							if (isset($dom[($dom[$trid]['parent'])]['attribute']['cellspacing'])) {
								$cellspacing = $this->getHTMLUnitToUnits($dom[($dom[$trid]['parent'])]['attribute']['cellspacing'], 1, 'px');
							} else {
								$cellspacing = 0;
							}
							if ($this->rtl) {
								$cellspacingx = -$cellspacing;
							} else {
								$cellspacingx = $cellspacing;
							}
							$colspan = $dom[$key]['attribute']['colspan'];
							$table_columns_width = ($table_width - ($cellspacing * ($dom[$table_el]['cols'] - 1)));
							$wtmp = ($colspan * ($table_columns_width / $dom[$table_el]['cols'])) + (($colspan - 1) * $cellspacing);
							if (isset($dom[$key]['width'])) {
								$cellw = $this->getHTMLUnitToUnits($dom[$key]['width'], $table_columns_width, 'px');
							} else {
								$cellw = $wtmp;
							}
							if (isset($dom[$key]['height'])) {
								// minimum cell height
								$cellh = $this->getHTMLUnitToUnits($dom[$key]['height'], 0, 'px');
							} else {
								$cellh = 0;
							}
							if (isset($dom[$key]['content'])) {
								$cell_content = $dom[$key]['content'];
							} else {
								$cell_content = ' ';
							}
							$tagtype = $dom[$key]['value'];
							$parentid = $key;
							while (($key < $maxel) AND (!(($dom[$key]['tag']) AND (!$dom[$key]['opening']) AND ($dom[$key]['value'] == $tagtype) AND ($dom[$key]['parent'] == $parentid)))) {
								// move $key index forward
								++$key;
							}
							if (!isset($dom[$trid]['startpage'])) {
								$dom[$trid]['startpage'] = $this->page;
							} else {
								$this->setPage($dom[$trid]['startpage']);
							}
							if (!isset($dom[$trid]['starty'])) {
								$dom[$trid]['starty'] = $this->y;
							} else {
								$this->y = $dom[$trid]['starty'];
							}
							if (!isset($dom[$trid]['startx'])) {
								$dom[$trid]['startx'] = $this->x;
							} else {
								$this->x += ($cellspacingx / 2);
							}
							if (isset($dom[$parentid]['attribute']['rowspan'])) {
								$rowspan = intval($dom[$parentid]['attribute']['rowspan']);
							} else {
								$rowspan = 1;
							}
							// skip row-spanned cells started on the previous rows
							if (isset($dom[$table_el]['rowspans'])) {
								$rsk = 0;
								$rskmax = count($dom[$table_el]['rowspans']);
								while ($rsk < $rskmax) {
									$trwsp = $dom[$table_el]['rowspans'][$rsk];
									$rsstartx = $trwsp['startx'];
									$rsendx = $trwsp['endx'];
									// account for margin changes
									if ($trwsp['startpage'] < $this->page) {
										if (($this->rtl) AND ($this->pagedim[$this->page]['orm'] != $this->pagedim[$trwsp['startpage']]['orm'])) {
											$dl = ($this->pagedim[$this->page]['orm'] - $this->pagedim[$trwsp['startpage']]['orm']);
											$rsstartx -= $dl;
											$rsendx -= $dl;
										} elseif ((!$this->rtl) AND ($this->pagedim[$this->page]['olm'] != $this->pagedim[$trwsp['startpage']]['olm'])) {
											$dl = ($this->pagedim[$this->page]['olm'] - $this->pagedim[$trwsp['startpage']]['olm']);
											$rsstartx += $dl;
											$rsendx += $dl;
										}
									}
									if  (($trwsp['rowspan'] > 0)
										AND ($rsstartx > ($this->x - $cellspacing - $currentcmargin - $this->feps))
										AND ($rsstartx < ($this->x + $cellspacing + $currentcmargin + $this->feps))
										AND (($trwsp['starty'] < ($this->y - $this->feps)) OR ($trwsp['startpage'] < $this->page))) {
										// set the starting X position of the current cell
										$this->x = $rsendx + $cellspacingx;
										if (($trwsp['rowspan'] == 1)
											AND (isset($dom[$trid]['endy']))
											AND (isset($dom[$trid]['endpage']))
											AND ($trwsp['endpage'] == $dom[$trid]['endpage'])) {
											// set ending Y position for row
											$dom[$table_el]['rowspans'][$rsk]['endy'] = max($dom[$trid]['endy'], $trwsp['endy']);
											$dom[$trid]['endy'] = $dom[$table_el]['rowspans'][$rsk]['endy'];
										}
										$rsk = 0;
									} else {
										++$rsk;
									}
								}
							}
							// add rowspan information to table element
							if ($rowspan > 1) {
								$trsid = array_push($dom[$table_el]['rowspans'], array('trid' => $trid, 'rowspan' => $rowspan, 'mrowspan' => $rowspan, 'colspan' => $colspan, 'startpage' => $this->page, 'startx' => $this->x, 'starty' => $this->y));
							}
							$cellid = array_push($dom[$trid]['cellpos'], array('startx' => $this->x));
							if ($rowspan > 1) {
								$dom[$trid]['cellpos'][($cellid - 1)]['rowspanid'] = ($trsid - 1);
							}
							// push background colors
							if (isset($dom[$parentid]['bgcolor']) AND ($dom[$parentid]['bgcolor'] !== false)) {
								$dom[$trid]['cellpos'][($cellid - 1)]['bgcolor'] = $dom[$parentid]['bgcolor'];
							}
							$prevLastH = $this->lasth;
							// ****** write the cell content ******
							$this->MultiCell($cellw, $cellh, $cell_content, false, $lalign, false, 2, '', '', true, 0, true);
							$this->lasth = $prevLastH;
							$this->cMargin = $oldmargin;
							$dom[$trid]['cellpos'][($cellid - 1)]['endx'] = $this->x;
							// update the end of row position
							if ($rowspan <= 1) {
								if (isset($dom[$trid]['endy'])) {
									if ($this->page == $dom[$trid]['endpage']) {
										$dom[$trid]['endy'] = max($this->y, $dom[$trid]['endy']);
									} elseif ($this->page > $dom[$trid]['endpage']) {
										$dom[$trid]['endy'] = $this->y;
									}
								} else {
									$dom[$trid]['endy'] = $this->y;
								}
								if (isset($dom[$trid]['endpage'])) {
									$dom[$trid]['endpage'] = max($this->page, $dom[$trid]['endpage']);
								} else {
									$dom[$trid]['endpage'] = $this->page;
								}
							} else {
								// account for row-spanned cells
								$dom[$table_el]['rowspans'][($trsid - 1)]['endx'] = $this->x;
								$dom[$table_el]['rowspans'][($trsid - 1)]['endy'] = $this->y;
								$dom[$table_el]['rowspans'][($trsid - 1)]['endpage'] = $this->page;
							}
							if (isset($dom[$table_el]['rowspans'])) {
								// update endy and endpage on rowspanned cells
								foreach ($dom[$table_el]['rowspans'] as $k => $trwsp) {
									if ($trwsp['rowspan'] > 0) {
										if (isset($dom[$trid]['endpage'])) {
											if ($trwsp['endpage'] == $dom[$trid]['endpage']) {
												$dom[$table_el]['rowspans'][$k]['endy'] = max($dom[$trid]['endy'], $trwsp['endy']);
											} elseif ($trwsp['endpage'] < $dom[$trid]['endpage']) {
												$dom[$table_el]['rowspans'][$k]['endy'] = $dom[$trid]['endy'];
												$dom[$table_el]['rowspans'][$k]['endpage'] = $dom[$trid]['endpage'];
											} else {
												$dom[$trid]['endy'] = $this->pagedim[$dom[$trid]['endpage']]['hk'] - $this->pagedim[$dom[$trid]['endpage']]['bm'];
											}
										}
									}
								}
							}
							$this->x += ($cellspacingx / 2);
						} else {
							// opening tag (or self-closing tag)
							if (!isset($opentagpos)) {
								if (!$this->InFooter) {
									if (isset($this->footerlen[$this->page])) {
										$this->footerpos[$this->page] = $this->pagelen[$this->page] - $this->footerlen[$this->page];
									} else {
										$this->footerpos[$this->page] = $this->pagelen[$this->page];
									}
									$opentagpos = $this->footerpos[$this->page];
								}
							}
							$this->openHTMLTagHandler($dom, $key, $cell);
						}
					} else {
						// closing tag
						$this->closeHTMLTagHandler($dom, $key, $cell, $maxbottomliney);
					}
				} elseif (strlen($dom[$key]['value']) > 0) {
					// print list-item
					if (!$this->empty_string($this->lispacer)) {
						$this->SetFont($pfontname, $pfontstyle, $pfontsize);
						$this->lasth = $this->FontSize * $this->cell_height_ratio;
						$minstartliney = $this->y;
						$maxbottomliney = ($startliney + ($this->FontSize * $this->cell_height_ratio));
						$this->putHtmlListBullet($this->listnum, $this->lispacer, $pfontsize);
						$this->SetFont($curfontname, $curfontstyle, $curfontsize);
						$this->lasth = $this->FontSize * $this->cell_height_ratio;
						if (is_numeric($pfontsize) AND ($pfontsize > 0) AND is_numeric($curfontsize) AND ($curfontsize > 0) AND ($pfontsize != $curfontsize)) {
							$pfontascent = $this->getFontAscent($pfontname, $pfontstyle, $pfontsize);
							$pfontdescent = $this->getFontDescent($pfontname, $pfontstyle, $pfontsize);
							$this->y += ((($pfontsize - $curfontsize) * $this->cell_height_ratio / $this->k) + $pfontascent - $curfontascent - $pfontdescent + $curfontdescent) / 2;
							$minstartliney = min($this->y, $minstartliney);
							$maxbottomliney = max(($this->y + (($pfontsize * $this->cell_height_ratio) / $this->k)), $maxbottomliney);
						}
					}
					// text
					$this->htmlvspace = 0;
					if ((!$this->premode) AND $this->isRTLTextDir()) {
						// reverse spaces order
						$len1 = strlen($dom[$key]['value']);
						$lsp = $len1 - strlen(ltrim($dom[$key]['value']));
						$rsp = $len1 - strlen(rtrim($dom[$key]['value']));
						$tmpstr = '';
						if ($rsp > 0) {
							$tmpstr .= substr($dom[$key]['value'], -$rsp);
						}
						$tmpstr .= trim($dom[$key]['value']);
						if ($lsp > 0) {
							$tmpstr .= substr($dom[$key]['value'], 0, $lsp);
						}
						$dom[$key]['value'] = $tmpstr;
					}
					if ($newline) {
						if (!$this->premode) {
							$prelen = strlen($dom[$key]['value']);
							if ($this->isRTLTextDir()) {
								$dom[$key]['value'] = rtrim($dom[$key]['value']).chr(0);
							} else {
								$dom[$key]['value'] = ltrim($dom[$key]['value']);
							}
							$postlen = strlen($dom[$key]['value']);
							if (($postlen == 0) AND ($prelen > 0)) {
								$dom[$key]['trimmed_space'] = true;
							}
						}
						$newline = false;
						$firstblock = true;
					} else {
						$firstblock = false;
					}
					$strrest = '';
					if ($this->rtl) {
						$this->x -= $this->textindent;
					} else {
						$this->x += $this->textindent;
					}
					if (!empty($this->HREF) AND (isset($this->HREF['url']))) {
						// HTML  Link
						$strrest = $this->addHtmlLink($this->HREF['url'], $dom[$key]['value'], $wfill, true, $this->HREF['color'], $this->HREF['style'], true);
					} else {
						// ****** write only until the end of the line and get the rest ******
						$strrest = $this->Write($this->lasth, $dom[$key]['value'], '', $wfill, '', false, 0, true, $firstblock, 0);
					}
					$this->textindent = 0;

					if (strlen($strrest) > 0) {
						// store the remaining string on the previous $key position
						$this->newline = true;
						if ($cell) {
							if ($this->rtl) {
								$this->x -= $this->cMargin;
							} else {
								$this->x += $this->cMargin;
							}
						}
						if ($strrest == $dom[$key]['value']) {
							// used to avoid infinite loop
							++$loop;
						} else {
							$loop = 0;
						}
						if (!empty($this->HREF) AND (isset($this->HREF['url']))) {
							$dom[$key]['value'] = trim($strrest);
						} elseif ($this->premode) {
							$dom[$key]['value'] = $strrest;
						} elseif ($this->isRTLTextDir()) {
							$dom[$key]['value'] = rtrim($strrest);
						} else {
							$dom[$key]['value'] = ltrim($strrest);
						}
						if ($loop < 3) {
							--$key;
						}
					} else {
						$loop = 0;
					}
				}
				++$key;
				if (isset($dom[$key]['tag']) AND $dom[$key]['tag'] AND (!isset($dom[$key]['opening']) OR !$dom[$key]['opening']) AND isset($dom[($dom[$key]['parent'])]['attribute']['nobr']) AND ($dom[($dom[$key]['parent'])]['attribute']['nobr'] == 'true')) {
					if ( (!$undo) AND (($this->start_transaction_page == ($this->numpages - 1)) OR ($this->y < $this->start_transaction_y))) {
						// restore previous object
						$this->rollbackTransaction(true);
						// restore previous values
						foreach ($this_method_vars as $vkey => $vval) {
							$$vkey = $vval;
						}
						// add a page (or trig AcceptPageBreak() for multicolumn mode)
						$pre_y = $this->y;
						if ((!$this->checkPageBreak($this->PageBreakTrigger + 1)) AND ($this->y < $pre_y)) {
							$startliney = $this->y;
						}
						$undo = true; // avoid infinite loop
					} else {
						$undo = false;
					}
				}
			} // end for each $key
			// align the last line
			if (isset($startlinex)) {
				$yshift = $minstartliney - $startliney;
				if (($yshift > 0) OR ($this->page > $startlinepage)) {
					$yshift = 0;
				}
				$t_x = 0;
				// the last line must be shifted to be aligned as requested
				$linew = abs($this->endlinex - $startlinex);
				$pstart = substr($this->getPageBuffer($startlinepage), 0, $startlinepos);
				if (isset($opentagpos) AND isset($this->footerlen[$startlinepage]) AND (!$this->InFooter)) {
					$this->footerpos[$startlinepage] = $this->pagelen[$startlinepage] - $this->footerlen[$startlinepage];
					$midpos = min($opentagpos, $this->footerpos[$startlinepage]);
				} elseif (isset($opentagpos)) {
					$midpos = $opentagpos;
				} elseif (isset($this->footerlen[$startlinepage]) AND (!$this->InFooter)) {
					$this->footerpos[$startlinepage] = $this->pagelen[$startlinepage] - $this->footerlen[$startlinepage];
					$midpos = $this->footerpos[$startlinepage];
				} else {
					$midpos = 0;
				}
				if ($midpos > 0) {
					$pmid = substr($this->getPageBuffer($startlinepage), $startlinepos, ($midpos - $startlinepos));
					$pend = substr($this->getPageBuffer($startlinepage), $midpos);
				} else {
					$pmid = substr($this->getPageBuffer($startlinepage), $startlinepos);
					$pend = '';
				}
				if ((isset($plalign) AND ((($plalign == 'C') OR (($plalign == 'R') AND (!$this->rtl)) OR (($plalign == 'L') AND ($this->rtl))))) OR ($yshift < 0)) {
					// calculate shifting amount
					$tw = $w;
					if ($this->lMargin != $prevlMargin) {
						$tw += ($prevlMargin - $this->lMargin);
					}
					if ($this->rMargin != $prevrMargin) {
						$tw += ($prevrMargin - $this->rMargin);
					}
					$one_space_width = $this->GetStringWidth(chr(32));
					$mdiff = abs($tw - $linew);
					if ($plalign == 'C') {
						if ($this->rtl) {
							$t_x = -($mdiff / 2);
						} else {
							$t_x = ($mdiff / 2);
						}
					} elseif (($plalign == 'R') AND (!$this->rtl)) {
						// right alignment on LTR document
						if (intval($this->revstrpos($pmid, ')]')) == (intval($this->revstrpos($pmid, ' )]')) + 1)) {
							// remove last space (if any)
							$linew -= $one_space_width;
							$mdiff = abs($tw - $linew);
						}
						$t_x = $mdiff;
					} elseif (($plalign == 'L') AND ($this->rtl)) {
						// left alignment on RTL document
						if (($this->revstrpos($pmid, '[(') > 0) AND ((intval($this->revstrpos($pmid, '[( ')) == intval($this->revstrpos($pmid, '[('))) OR (intval($this->revstrpos($pmid, '[('.chr(0).chr(32))) == intval($this->revstrpos($pmid, '[('))))) {
							// remove first space (if any)
							$linew -= $one_space_width;
						}
						if ((strpos($pmid, '[(') > 0) AND (intval(strpos($pmid, '[(')) == (intval($this->revstrpos($pmid, '[('))))) {
							// remove last space (if any)
							$linew -= $one_space_width;
							if (($this->CurrentFont['type'] == 'TrueTypeUnicode') OR ($this->CurrentFont['type'] == 'cidfont0')) {
								$linew -= $one_space_width;
							}
						}
						$mdiff = abs($tw - $linew);
						$t_x = -$mdiff;
					}
				} // end if startlinex
				if (($t_x != 0) OR ($yshift < 0)) {
					// shift the line
					$trx = sprintf('1 0 0 1 %.3F %.3F cm', ($t_x * $this->k), ($yshift * $this->k));
					$this->setPageBuffer($startlinepage, $pstart."\nq\n".$trx."\n".$pmid."\nQ\n".$pend);
					$endlinepos = strlen($pstart."\nq\n".$trx."\n".$pmid."\nQ\n");
					// shift the annotations and links
					if (isset($this->PageAnnots[$this->page])) {
						foreach ($this->PageAnnots[$this->page] as $pak => $pac) {
							if ($pak >= $pask) {
								$this->PageAnnots[$this->page][$pak]['x'] += $t_x;
								$this->PageAnnots[$this->page][$pak]['y'] -= $yshift;
							}
						}
					}
					$this->y -= $yshift;
				}
			}
			if ($ln AND (!($cell AND ($dom[$key-1]['value'] == 'table')))) {
				$this->Ln($this->lasth);
				if ($this->y < $maxbottomliney) {
					$this->y = $maxbottomliney;
				}
			}
			// restore previous values
			$this->setGraphicVars($gvars);
			if ($this->page > $prevPage) {
				$this->lMargin = $this->pagedim[$this->page]['olm'];
				$this->rMargin = $this->pagedim[$this->page]['orm'];
			}
			// restore previous list state
			$this->cell_height_ratio = $prev_cell_height_ratio;
			$this->listnum = $prev_listnum;
			$this->listordered = $prev_listordered;
			$this->listcount = $prev_listcount;
			$this->lispacer = $prev_lispacer;
			unset($dom);
		}

		/**
		 * Process opening tags.
		 * @param array $dom html dom array
		 * @param int $key current element id
		 * @param boolean $cell if true add the default cMargin space to each new line (default false).
		 * @access protected
		 */
		protected function openHTMLTagHandler(&$dom, $key, $cell) {
			$tag = $dom[$key];
			$parent = $dom[($dom[$key]['parent'])];
			$firstorlast = ($key == 1);
			// check for text direction attribute
			if (isset($tag['attribute']['dir'])) {
				$this->setTempRTL($tag['attribute']['dir']);
			} else {
				$this->tmprtl = false;
			}
			if ($tag['block']) {
				$hbz = 0; // distance from y to line bottom
				$hb = 0; // vertical space between block tags
				// calculate vertical space for block tags
				if (isset($this->tagvspaces[$tag['value']][0]['h']) AND ($this->tagvspaces[$tag['value']][0]['h'] >= 0)) {
					$cur_h = $this->tagvspaces[$tag['value']][0]['h'];
				} elseif (isset($tag['fontsize'])) {
					$cur_h = ($tag['fontsize'] / $this->k) * $this->cell_height_ratio;
				} else {
					$cur_h = $this->FontSize * $this->cell_height_ratio;
				}
				if (isset($this->tagvspaces[$tag['value']][0]['n'])) {
					$n = $this->tagvspaces[$tag['value']][0]['n'];
				} elseif (preg_match('/[h][0-9]/', $tag['value']) > 0) {
					$n = 0.6;
				} else {
					$n = 1;
				}
				$hb = ($n * $cur_h);
				if (($this->htmlvspace <= 0) AND ($n > 0)) {
					if (isset($parent['fontsize'])) {
						$hbz = (($parent['fontsize'] / $this->k) * $this->cell_height_ratio);
					} else {
						$hbz = $this->FontSize * $this->cell_height_ratio;
					}
				}
			}
			//Opening tag
			switch($tag['value']) {
				case 'table': {
					$cp = 0;
					$cs = 0;
					$dom[$key]['rowspans'] = array();
					if (!isset($dom[$key]['attribute']['nested']) OR ($dom[$key]['attribute']['nested'] != 'true')) {
						// set table header
						if (!$this->empty_string($dom[$key]['thead'])) {
							// set table header
							$this->thead = $dom[$key]['thead'];
							if (!isset($this->theadMargins) OR (empty($this->theadMargins))) {
								$this->theadMargins = array();
								$this->theadMargins['cmargin'] = $this->cMargin;
							}
						}
					}
					if (isset($tag['attribute']['cellpadding'])) {
						$cp = $this->getHTMLUnitToUnits($tag['attribute']['cellpadding'], 1, 'px');
						$this->oldcMargin = $this->cMargin;
						$this->cMargin = $cp;
					}
					if (isset($tag['attribute']['cellspacing'])) {
						$cs = $this->getHTMLUnitToUnits($tag['attribute']['cellspacing'], 1, 'px');
					}
					if ($this->checkPageBreak(((2 * $cp) + (2 * $cs) + $this->lasth), '', false)) {
						$this->inthead = true;
						// add a page (or trig AcceptPageBreak() for multicolumn mode)
						$this->checkPageBreak($this->PageBreakTrigger + 1);
					}
					break;
				}
				case 'tr': {
					// array of columns positions
					$dom[$key]['cellpos'] = array();
					break;
				}
				case 'hr': {
					$wtmp = $this->w - $this->lMargin - $this->rMargin;
					if ((isset($tag['attribute']['width'])) AND ($tag['attribute']['width'] != '')) {
						$hrWidth = $this->getHTMLUnitToUnits($tag['attribute']['width'], $wtmp, 'px');
					} else {
						$hrWidth = $wtmp;
					}
					if ((isset($tag['height'])) AND ($tag['height'] != '')) {
						$hrHeight = $this->getHTMLUnitToUnits($tag['height'], 1, 'px');
					} else {
						$hrHeight = $this->GetLineWidth();
					}
					$this->addHTMLVertSpace($hbz, ($hrHeight / 2), $cell, $firstorlast);
					$x = $this->GetX();
					$y = $this->GetY();
					$prevlinewidth = $this->GetLineWidth();
					$this->SetLineWidth($hrHeight);
					$this->Line($x, $y, $x + $hrWidth, $y);
					$this->SetLineWidth($prevlinewidth);
					$this->addHTMLVertSpace(($hrHeight / 2), 0, $cell, !isset($dom[($key + 1)]));
					break;
				}
				case 'a': {
					if (array_key_exists('href', $tag['attribute'])) {
						$this->HREF['url'] = $tag['attribute']['href'];
					}
					$this->HREF['color'] = $this->htmlLinkColorArray;
					$this->HREF['style'] = $this->htmlLinkFontStyle;
					if (array_key_exists('style', $tag['attribute'])) {
						// get style attributes
						preg_match_all('/([^;:\s]*):([^;]*)/', $tag['attribute']['style'], $style_array, PREG_PATTERN_ORDER);
						$astyle = array();
						while (list($id, $name) = each($style_array[1])) {
							$name = strtolower($name);
							$astyle[$name] = trim($style_array[2][$id]);
						}
						if (isset($astyle['color'])) {
							$this->HREF['color'] = $this->convertHTMLColorToDec($astyle['color']);
						}
						if (isset($astyle['text-decoration'])) {
							$this->HREF['style'] = '';
							$decors = explode(' ', strtolower($astyle['text-decoration']));
							foreach ($decors as $dec) {
								$dec = trim($dec);
								if (!$this->empty_string($dec)) {
									if ($dec{0} == 'u') {
										// underline
										$this->HREF['style'] .= 'U';
									} elseif ($dec{0} == 'l') {
										// line-trough
										$this->HREF['style'] .= 'D';
									} elseif ($dec{0} == 'o') {
										// overline
										$this->HREF['style'] .= 'O';
									}
								}
							}
						}
					}
					break;
				}
				case 'img': {
					if (isset($tag['attribute']['src'])) {
						// replace relative path with real server path
						if (($tag['attribute']['src'][0] == '/') AND ($_SERVER['DOCUMENT_ROOT'] != '/')) {
							$findroot = strpos($tag['attribute']['src'], $_SERVER['DOCUMENT_ROOT']);
							if (($findroot === false) OR ($findroot > 1)) {
								$tag['attribute']['src'] = $_SERVER['DOCUMENT_ROOT'].$tag['attribute']['src'];
							}
						}
						$tag['attribute']['src'] = urldecode($tag['attribute']['src']);
						$type = $this->getImageFileType($tag['attribute']['src']);
						$testscrtype = @parse_url($tag['attribute']['src']);
						if (!isset($testscrtype['query']) OR empty($testscrtype['query'])) {
							// convert URL to server path
							$tag['attribute']['src'] = str_replace(K_PATH_URL, K_PATH_MAIN, $tag['attribute']['src']);
						}
						if (!isset($tag['attribute']['width'])) {
							$tag['attribute']['width'] = 0;
						}
						if (!isset($tag['attribute']['height'])) {
							$tag['attribute']['height'] = 0;
						}
						//if (!isset($tag['attribute']['align'])) {
							// the only alignment supported is "bottom"
							// further development is required for other modes.
							$tag['attribute']['align'] = 'bottom';
						//}
						switch($tag['attribute']['align']) {
							case 'top': {
								$align = 'T';
								break;
							}
							case 'middle': {
								$align = 'M';
								break;
							}
							case 'bottom': {
								$align = 'B';
								break;
							}
							default: {
								$align = 'B';
								break;
							}
						}
						$prevy = $this->y;
						$xpos = $this->x;
						// eliminate marker spaces
						if (isset($dom[($key - 1)])) {
							if (($dom[($key - 1)]['value'] == ' ') OR (isset($dom[($key - 1)]['trimmed_space']))) {
								$xpos -= $this->GetStringWidth(chr(32));
							} elseif ($this->rtl AND $dom[($key - 1)]['value'] == '  ') {
								$xpos += (2 * $this->GetStringWidth(chr(32)));
							}
						}
						$imglink = '';
						if (isset($this->HREF['url']) AND !$this->empty_string($this->HREF['url'])) {
							$imglink = $this->HREF['url'];
							if ($imglink{0} == '#') {
								// convert url to internal link
								$page = intval(substr($imglink, 1));
								$imglink = $this->AddLink();
								$this->SetLink($imglink, 0, $page);
							}
						}
						$border = 0;
						if (isset($tag['attribute']['border']) AND !empty($tag['attribute']['border'])) {
							// currently only support 1 (frame) or a combination of 'LTRB'
							$border = $tag['attribute']['border'];
						}
						$iw = '';
						if (isset($tag['attribute']['width'])) {
							$iw = $this->getHTMLUnitToUnits($tag['attribute']['width'], 1, 'px', false);
						}
						$ih = '';
						if (isset($tag['attribute']['height'])) {
							$ih = $this->getHTMLUnitToUnits($tag['attribute']['height'], 1, 'px', false);
						}
						if (($type == 'eps') OR ($type == 'ai')) {
							$this->ImageEps($tag['attribute']['src'], $xpos, $this->y, $iw, $ih, $imglink, true, $align, '', $border, true);
						} elseif ($type == 'svg') {
							$this->ImageSVG($tag['attribute']['src'], $xpos, $this->y, $iw, $ih, $imglink, $align, '', $border, true);
						} else  {
							$this->Image($tag['attribute']['src'], $xpos, $this->y, $iw, $ih, '', $imglink, $align, false, 300, '', false, false, $border, false, false, true);
						}
						switch($align) {
							case 'T': {
								$this->y = $prevy;
								break;
							}
							case 'M': {
								$this->y = (($this->img_rb_y + $prevy - ($tag['fontsize'] / $this->k)) / 2) ;
								break;
							}
							case 'B': {
								$this->y = $this->img_rb_y - ($tag['fontsize'] / $this->k);
								break;
							}
						}
					}
					break;
				}
				case 'dl': {
					++$this->listnum;
					if ($this->listnum == 1) {
						$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					} else {
						$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					}
					break;
				}
				case 'dt': {
					$this->addHTMLVertSpace($hbz, 0, $cell, $firstorlast);
					break;
				}
				case 'dd': {
					if ($this->rtl) {
						$this->rMargin += $this->listindent;
					} else {
						$this->lMargin += $this->listindent;
					}
					++$this->listindentlevel;
					$this->addHTMLVertSpace($hbz, 0, $cell, $firstorlast);
					break;
				}
				case 'ul':
				case 'ol': {
					++$this->listnum;
					if ($tag['value'] == 'ol') {
						$this->listordered[$this->listnum] = true;
					} else {
						$this->listordered[$this->listnum] = false;
					}
					if (isset($tag['attribute']['start'])) {
						$this->listcount[$this->listnum] = intval($tag['attribute']['start']) - 1;
					} else {
						$this->listcount[$this->listnum] = 0;
					}
					if ($this->rtl) {
						$this->rMargin += $this->listindent;
					} else {
						$this->lMargin += $this->listindent;
					}
					++$this->listindentlevel;
					if ($this->listnum == 1) {
						$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					} else {
						$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					}
					break;
				}
				case 'li': {
					$this->addHTMLVertSpace($hbz, 0, $cell, $firstorlast);
					if ($this->listordered[$this->listnum]) {
						// ordered item
						if (isset($parent['attribute']['type']) AND !$this->empty_string($parent['attribute']['type'])) {
							$this->lispacer = $parent['attribute']['type'];
						} elseif (isset($parent['listtype']) AND !$this->empty_string($parent['listtype'])) {
							$this->lispacer = $parent['listtype'];
						} elseif (isset($this->lisymbol) AND !$this->empty_string($this->lisymbol)) {
							$this->lispacer = $this->lisymbol;
						} else {
							$this->lispacer = '#';
						}
						++$this->listcount[$this->listnum];
						if (isset($tag['attribute']['value'])) {
							$this->listcount[$this->listnum] = intval($tag['attribute']['value']);
						}
					} else {
						// unordered item
						if (isset($parent['attribute']['type']) AND !$this->empty_string($parent['attribute']['type'])) {
							$this->lispacer = $parent['attribute']['type'];
						} elseif (isset($parent['listtype']) AND !$this->empty_string($parent['listtype'])) {
							$this->lispacer = $parent['listtype'];
						} elseif (isset($this->lisymbol) AND !$this->empty_string($this->lisymbol)) {
							$this->lispacer = $this->lisymbol;
						} else {
							$this->lispacer = '!';
						}
					}
					break;
				}
				case 'blockquote': {
					if ($this->rtl) {
						$this->rMargin += $this->listindent;
					} else {
						$this->lMargin += $this->listindent;
					}
					++$this->listindentlevel;
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					break;
				}
				case 'br': {
					$this->addHTMLVertSpace($hbz, 0, $cell, $firstorlast);
					break;
				}
				case 'div': {
					$this->addHTMLVertSpace($hbz, 0, $cell, $firstorlast);
					break;
				}
				case 'p': {
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					break;
				}
				case 'pre': {
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					$this->premode = true;
					break;
				}
				case 'sup': {
					$this->SetXY($this->GetX(), $this->GetY() - ((0.7 * $this->FontSizePt) / $this->k));
					break;
				}
				case 'sub': {
					$this->SetXY($this->GetX(), $this->GetY() + ((0.3 * $this->FontSizePt) / $this->k));
					break;
				}
				case 'h1':
				case 'h2':
				case 'h3':
				case 'h4':
				case 'h5':
				case 'h6': {
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					break;
				}
				// Form fields (since 4.8.000 - 2009-09-07)
				case 'form': {
					if (isset($tag['attribute']['action'])) {
						$this->form_action = $tag['attribute']['action'];
					} else {
						$this->form_action = K_PATH_URL.$_SERVER['SCRIPT_NAME'];
					}
					if (isset($tag['attribute']['enctype'])) {
						$this->form_enctype = $tag['attribute']['enctype'];
					} else {
						$this->form_enctype = 'application/x-www-form-urlencoded';
					}
					if (isset($tag['attribute']['method'])) {
						$this->form_mode = $tag['attribute']['method'];
					} else {
						$this->form_mode = 'post';
					}
					break;
				}
				case 'input': {
					if (isset($tag['attribute']['name']) AND !$this->empty_string($tag['attribute']['name'])) {
						$name = $tag['attribute']['name'];
					} else {
						break;
					}
					$prop = array();
					$opt = array();
					if (isset($tag['attribute']['value']) AND !$this->empty_string($tag['attribute']['value'])) {
						$value = $tag['attribute']['value'];
					}
					if (isset($tag['attribute']['maxlength']) AND !$this->empty_string($tag['attribute']['maxlength'])) {
						$opt['maxlen'] = intval($tag['attribute']['value']);
					}
					$h = $this->FontSize * $this->cell_height_ratio;
					if (isset($tag['attribute']['size']) AND !$this->empty_string($tag['attribute']['size'])) {
						$w = intval($tag['attribute']['size']) * $this->GetStringWidth(chr(32)) * 2;
					} else {
						$w = $h;
					}
					if (isset($tag['attribute']['checked']) AND (($tag['attribute']['checked'] == 'checked') OR ($tag['attribute']['checked'] == 'true'))) {
						$checked = true;
					} else {
						$checked = false;
					}
					switch ($tag['attribute']['type']) {
						case 'text': {
							if (isset($value)) {
								$opt['v'] = $value;
							}
							$this->TextField($name, $w, $h, $prop, $opt, '', '', false);
							break;
						}
						case 'password': {
							if (isset($value)) {
								$opt['v'] = $value;
							}
							$prop['password'] = 'true';
							$this->TextField($name, $w, $h, $prop, $opt, '', '', false);
							break;
						}
						case 'checkbox': {
							$this->CheckBox($name, $w, $checked, $prop, $opt, $value, '', '', false);
							break;
						}
						case 'radio': {
							$this->RadioButton($name, $w, $prop, $opt, $value, $checked, '', '', false);
							break;
						}
						case 'submit': {
							$w = $this->GetStringWidth($value) * 1.5;
							$h *= 1.6;
							$prop = array('lineWidth'=>1, 'borderStyle'=>'beveled', 'fillColor'=>array(196, 196, 196), 'strokeColor'=>array(255, 255, 255));
							$action = array();
							$action['S'] = 'SubmitForm';
							$action['F'] = $this->form_action;
							if ($this->form_enctype != 'FDF') {
								$action['Flags'] = array('ExportFormat');
							}
							if ($this->form_mode == 'get') {
								$action['Flags'] = array('GetMethod');
							}
							$this->Button($name, $w, $h, $value, $action, $prop, $opt, '', '', false);
							break;
						}
						case 'reset': {
							$w = $this->GetStringWidth($value) * 1.5;
							$h *= 1.6;
							$prop = array('lineWidth'=>1, 'borderStyle'=>'beveled', 'fillColor'=>array(196, 196, 196), 'strokeColor'=>array(255, 255, 255));
							$this->Button($name, $w, $h, $value, array('S'=>'ResetForm'), $prop, $opt, '', '', false);
							break;
						}
						case 'file': {
							$prop['fileSelect'] = 'true';
							$this->TextField($name, $w, $h, $prop, $opt, '', '', false);
							if (!isset($value)) {
								$value = '*';
							}
							$w = $this->GetStringWidth($value) * 2;
							$h *= 1.2;
							$prop = array('lineWidth'=>1, 'borderStyle'=>'beveled', 'fillColor'=>array(196, 196, 196), 'strokeColor'=>array(255, 255, 255));
							$jsaction = 'var f=this.getField(\''.$name.'\'); f.browseForFileToSubmit();';
							$this->Button('FB_'.$name, $w, $h, $value, $jsaction, $prop, $opt, '', '', false);
							break;
						}
						case 'hidden': {
							if (isset($value)) {
								$opt['v'] = $value;
							}
							$opt['f'] = array('invisible', 'hidden');
							$this->TextField($name, 0, 0, $prop, $opt, '', '', false);
							break;
						}
						case 'image': {
							// THIS TYPE MUST BE FIXED
							if (isset($tag['attribute']['src']) AND !$this->empty_string($tag['attribute']['src'])) {
								$img = $tag['attribute']['src'];
							} else {
								break;
							}
							$value = 'img';
							//$opt['mk'] = array('i'=>$img, 'tp'=>1, 'if'=>array('sw'=>'A', 's'=>'A', 'fb'=>false));
							if (isset($tag['attribute']['onclick']) AND !empty($tag['attribute']['onclick'])) {
								$jsaction = $tag['attribute']['onclick'];
							} else {
								$jsaction = '';
							}
							$this->Button($name, $w, $h, $value, $jsaction, $prop, $opt, '', '', false);
							break;
						}
						case 'button': {
							$w = $this->GetStringWidth($value) * 1.5;
							$h *= 1.6;
							$prop = array('lineWidth'=>1, 'borderStyle'=>'beveled', 'fillColor'=>array(196, 196, 196), 'strokeColor'=>array(255, 255, 255));
							if (isset($tag['attribute']['onclick']) AND !empty($tag['attribute']['onclick'])) {
								$jsaction = $tag['attribute']['onclick'];
							} else {
								$jsaction = '';
							}
							$this->Button($name, $w, $h, $value, $jsaction, $prop, $opt, '', '', false);
							break;
						}
					}
					break;
				}
				case 'textarea': {
					$prop = array();
					$opt = array();
					if (isset($tag['attribute']['name']) AND !$this->empty_string($tag['attribute']['name'])) {
						$name = $tag['attribute']['name'];
					} else {
						break;
					}
					if (isset($tag['attribute']['value']) AND !$this->empty_string($tag['attribute']['value'])) {
						$opt['v'] = $tag['attribute']['value'];
					}
					if (isset($tag['attribute']['cols']) AND !$this->empty_string($tag['attribute']['cols'])) {
						$w = intval($tag['attribute']['cols']) * $this->GetStringWidth(chr(32)) * 2;
					} else {
						$w = 40;
					}
					if (isset($tag['attribute']['rows']) AND !$this->empty_string($tag['attribute']['rows'])) {
						$h = intval($tag['attribute']['rows']) * $this->FontSize * $this->cell_height_ratio;
					} else {
						$h = 10;
					}
					$prop['multiline'] = 'true';
					$this->TextField($name, $w, $h, $prop, $opt, '', '', false);
					break;
				}
				case 'select': {
					$h = $this->FontSize * $this->cell_height_ratio;
					if (isset($tag['attribute']['size']) AND !$this->empty_string($tag['attribute']['size'])) {
						$h *= ($tag['attribute']['size'] + 1);
					}
					$prop = array();
					$opt = array();
					if (isset($tag['attribute']['name']) AND !$this->empty_string($tag['attribute']['name'])) {
						$name = $tag['attribute']['name'];
					} else {
						break;
					}
					$w = 0;
					if (isset($tag['attribute']['opt']) AND !$this->empty_string($tag['attribute']['opt'])) {
						$options = explode ("\r", $tag['attribute']['opt']);
						$values = array();
						foreach ($options as $val) {
							if (strpos($val, "\t") !== false) {
								$opts = explode("\t", $val);
								$values[] = $opts;
								$w = max($w, $this->GetStringWidth($opts[1]));
							} else {
								$values[] = $val;
								$w = max($w, $this->GetStringWidth($val));
							}
						}
					} else {
						break;
					}
					$w *= 2;
					if (isset($tag['attribute']['multiple']) AND ($tag['attribute']['multiple']='multiple')) {
						$prop['multipleSelection'] = 'true';
						$this->ListBox($name, $w, $h, $values, $prop, $opt, '', '', false);
					} else {
						$this->ComboBox($name, $w, $h, $values, $prop, $opt, '', '', false);
					}
					break;
				}
				case 'tcpdf': {
					if (defined('K_TCPDF_CALLS_IN_HTML') AND (K_TCPDF_CALLS_IN_HTML === true)) {
						// Special tag used to call TCPDF methods
						if (isset($tag['attribute']['method'])) {
							$tcpdf_method = $tag['attribute']['method'];
							if (method_exists($this, $tcpdf_method)) {
								if (isset($tag['attribute']['params']) AND (!empty($tag['attribute']['params']))) {
									$params = unserialize(urldecode($tag['attribute']['params']));
									call_user_func_array(array($this, $tcpdf_method), $params);
								} else {
									$this->$tcpdf_method();
								}
								$this->newline = true;
							}
						}
					}
					break;
				}
				default: {
					break;
				}
			}
			if ($dom[$key]['self'] AND isset($dom[$key]['attribute']['pagebreakafter'])) {
				$pba = $dom[$key]['attribute']['pagebreakafter'];
				// check for pagebreak
				if (($pba == 'true') OR ($pba == 'left') OR ($pba == 'right')) {
					// add a page (or trig AcceptPageBreak() for multicolumn mode)
					$this->checkPageBreak($this->PageBreakTrigger + 1);
				}
				if ((($pba == 'left') AND (((!$this->rtl) AND (($this->page % 2) == 0)) OR (($this->rtl) AND (($this->page % 2) != 0))))
					OR (($pba == 'right') AND (((!$this->rtl) AND (($this->page % 2) != 0)) OR (($this->rtl) AND (($this->page % 2) == 0))))) {
					// add a page (or trig AcceptPageBreak() for multicolumn mode)
					$this->checkPageBreak($this->PageBreakTrigger + 1);
				}
			}
		}

		/**
		 * Process closing tags.
		 * @param array $dom html dom array
		 * @param int $key current element id
		 * @param boolean $cell if true add the default cMargin space to each new line (default false).
		 * @param int $maxbottomliney maximum y value of current line
		 * @access protected
		 */
		protected function closeHTMLTagHandler(&$dom, $key, $cell, $maxbottomliney=0) {
			$tag = $dom[$key];
			$parent = $dom[($dom[$key]['parent'])];
			$firstorlast = ((!isset($dom[($key + 1)])) OR ((!isset($dom[($key + 2)])) AND ($dom[($key + 1)]['value'] == 'marker')));
			$in_table_head = false;
			if ($tag['block']) {
				$hbz = 0; // distance from y to line bottom
				$hb = 0; // vertical space between block tags
				// calculate vertical space for block tags
				if (isset($this->tagvspaces[$tag['value']][1]['h']) AND ($this->tagvspaces[$tag['value']][1]['h'] >= 0)) {
					$pre_h = $this->tagvspaces[$tag['value']][1]['h'];
				} elseif (isset($parent['fontsize'])) {
					$pre_h = (($parent['fontsize'] / $this->k) * $this->cell_height_ratio);
				} else {
					$pre_h = $this->FontSize * $this->cell_height_ratio;
				}
				if (isset($this->tagvspaces[$tag['value']][1]['n'])) {
					$n = $this->tagvspaces[$tag['value']][1]['n'];
				} elseif (preg_match('/[h][0-9]/', $tag['value']) > 0) {
					$n = 0.6;
				} else {
					$n = 1;
				}
				$hb = ($n * $pre_h);
				if ($this->y < $maxbottomliney) {
					$hbz = ($maxbottomliney - $this->y);
				}
			}
			//Closing tag
			switch($tag['value']) {
				case 'tr': {
					$table_el = $dom[($dom[$key]['parent'])]['parent'];
					if (!isset($parent['endy'])) {
						$dom[($dom[$key]['parent'])]['endy'] = $this->y;
						$parent['endy'] = $this->y;
					}
					if (!isset($parent['endpage'])) {
						$dom[($dom[$key]['parent'])]['endpage'] = $this->page;
						$parent['endpage'] = $this->page;
					}
					// update row-spanned cells
					if (isset($dom[$table_el]['rowspans'])) {
						foreach ($dom[$table_el]['rowspans'] as $k => $trwsp) {
							$dom[$table_el]['rowspans'][$k]['rowspan'] -= 1;
							if ($dom[$table_el]['rowspans'][$k]['rowspan'] == 0) {
								if ($dom[$table_el]['rowspans'][$k]['endpage'] == $parent['endpage']) {
									$dom[($dom[$key]['parent'])]['endy'] = max($dom[$table_el]['rowspans'][$k]['endy'], $parent['endy']);
								} elseif ($dom[$table_el]['rowspans'][$k]['endpage'] > $parent['endpage']) {
									$dom[($dom[$key]['parent'])]['endy'] = $dom[$table_el]['rowspans'][$k]['endy'];
									$dom[($dom[$key]['parent'])]['endpage'] = $dom[$table_el]['rowspans'][$k]['endpage'];
								}
							}
						}
						// report new endy and endpage to the rowspanned cells
						foreach ($dom[$table_el]['rowspans'] as $k => $trwsp) {
							if ($dom[$table_el]['rowspans'][$k]['rowspan'] == 0) {
								$dom[$table_el]['rowspans'][$k]['endpage'] = max($dom[$table_el]['rowspans'][$k]['endpage'], $dom[($dom[$key]['parent'])]['endpage']);
								$dom[($dom[$key]['parent'])]['endpage'] = $dom[$table_el]['rowspans'][$k]['endpage'];
								$dom[$table_el]['rowspans'][$k]['endy'] = max($dom[$table_el]['rowspans'][$k]['endy'], $dom[($dom[$key]['parent'])]['endy']);
								$dom[($dom[$key]['parent'])]['endy'] = $dom[$table_el]['rowspans'][$k]['endy'];
							}
						}
						// update remaining rowspanned cells
						foreach ($dom[$table_el]['rowspans'] as $k => $trwsp) {
							if ($dom[$table_el]['rowspans'][$k]['rowspan'] == 0) {
								$dom[$table_el]['rowspans'][$k]['endpage'] = $dom[($dom[$key]['parent'])]['endpage'];
								$dom[$table_el]['rowspans'][$k]['endy'] = $dom[($dom[$key]['parent'])]['endy'];
							}
						}
					}
					if (($this->num_columns > 1) AND ($dom[($dom[$key]['parent'])]['endy'] >= ($this->PageBreakTrigger - $this->lasth)) AND ($this->y < $dom[($dom[$key]['parent'])]['endy'])) {
						$this->Ln(0, $cell);
					} else {
						$this->setPage($dom[($dom[$key]['parent'])]['endpage']);
						$this->y = $dom[($dom[$key]['parent'])]['endy'];
						if (isset($dom[$table_el]['attribute']['cellspacing'])) {
							$cellspacing = $this->getHTMLUnitToUnits($dom[$table_el]['attribute']['cellspacing'], 1, 'px');
							$this->y += $cellspacing;
						}
						$this->Ln(0, $cell);
						$this->x = $parent['startx'];
						// account for booklet mode
						if ($this->page > $parent['startpage']) {
							if (($this->rtl) AND ($this->pagedim[$this->page]['orm'] != $this->pagedim[$parent['startpage']]['orm'])) {
								$this->x -= ($this->pagedim[$this->page]['orm'] - $this->pagedim[$parent['startpage']]['orm']);
							} elseif ((!$this->rtl) AND ($this->pagedim[$this->page]['olm'] != $this->pagedim[$parent['startpage']]['olm'])) {
								$this->x += ($this->pagedim[$this->page]['olm'] - $this->pagedim[$parent['startpage']]['olm']);
							}
						}
					}
					break;
				}
				case 'tablehead':
					// closing tag used for the thead part
					$in_table_head = true;
					$this->inthead = false;
				case 'table': {
					$table_el = $parent;
					// draw borders
					if ((isset($table_el['attribute']['border']) AND ($table_el['attribute']['border'] > 0))
						OR (isset($table_el['style']['border']) AND ($table_el['style']['border'] > 0))) {
							$border = 1;
					} else {
						$border = 0;
					}
					// fix bottom line alignment of last line before page break
					foreach ($dom[($dom[$key]['parent'])]['trids'] as $j => $trkey) {
						// update row-spanned cells
						if (isset($dom[($dom[$key]['parent'])]['rowspans'])) {
							foreach ($dom[($dom[$key]['parent'])]['rowspans'] as $k => $trwsp) {
								if ($trwsp['trid'] == $trkey) {
									$dom[($dom[$key]['parent'])]['rowspans'][$k]['mrowspan'] -= 1;
								}
								if (isset($prevtrkey) AND ($trwsp['trid'] == $prevtrkey) AND ($trwsp['mrowspan'] >= 0)) {
									$dom[($dom[$key]['parent'])]['rowspans'][$k]['trid'] = $trkey;
								}
							}
						}
						if (isset($prevtrkey) AND ($dom[$trkey]['startpage'] > $dom[$prevtrkey]['endpage'])) {
							$pgendy = $this->pagedim[$dom[$prevtrkey]['endpage']]['hk'] - $this->pagedim[$dom[$prevtrkey]['endpage']]['bm'];
							$dom[$prevtrkey]['endy'] = $pgendy;
							// update row-spanned cells
							if (isset($dom[($dom[$key]['parent'])]['rowspans'])) {
								foreach ($dom[($dom[$key]['parent'])]['rowspans'] as $k => $trwsp) {
									if (($trwsp['trid'] == $trkey) AND ($trwsp['mrowspan'] > 1) AND ($trwsp['endpage'] == $dom[$prevtrkey]['endpage'])) {
										$dom[($dom[$key]['parent'])]['rowspans'][$k]['endy'] = $pgendy;
										$dom[($dom[$key]['parent'])]['rowspans'][$k]['mrowspan'] = -1;
									}
								}
							}
						}
						$prevtrkey = $trkey;
						$table_el = $dom[($dom[$key]['parent'])];
					}
					// for each row
					foreach ($table_el['trids'] as $j => $trkey) {
						$parent = $dom[$trkey];
						// for each cell on the row
						foreach ($parent['cellpos'] as $k => $cellpos) {
							if (isset($cellpos['rowspanid']) AND ($cellpos['rowspanid'] >= 0)) {
								$cellpos['startx'] = $table_el['rowspans'][($cellpos['rowspanid'])]['startx'];
								$cellpos['endx'] = $table_el['rowspans'][($cellpos['rowspanid'])]['endx'];
								$endy = $table_el['rowspans'][($cellpos['rowspanid'])]['endy'];
								$startpage = $table_el['rowspans'][($cellpos['rowspanid'])]['startpage'];
								$endpage = $table_el['rowspans'][($cellpos['rowspanid'])]['endpage'];
							} else {
								$endy = $parent['endy'];
								$startpage = $parent['startpage'];
								$endpage = $parent['endpage'];
							}
							if ($endpage > $startpage) {
								// design borders around HTML cells.
								for ($page=$startpage; $page <= $endpage; ++$page) {
									$this->setPage($page);
									if ($page == $startpage) {
										$this->y = $parent['starty']; // put cursor at the beginning of row on the first page
										$ch = $this->getPageHeight() - $parent['starty'] - $this->getBreakMargin();
										$cborder = $this->getBorderMode($border, $position='start');
									} elseif ($page == $endpage) {
										$this->y = $this->tMargin; // put cursor at the beginning of last page
										$ch = $endy - $this->tMargin;
										$cborder = $this->getBorderMode($border, $position='end');
									} else {
										$this->y = $this->tMargin; // put cursor at the beginning of the current page
										$ch = $this->getPageHeight() - $this->tMargin - $this->getBreakMargin();
										$cborder = $this->getBorderMode($border, $position='middle');
									}
									if (isset($cellpos['bgcolor']) AND ($cellpos['bgcolor']) !== false) {
										$this->SetFillColorArray($cellpos['bgcolor']);
										$fill = true;
									} else {
										$fill = false;
									}
									$cw = abs($cellpos['endx'] - $cellpos['startx']);
									$this->x = $cellpos['startx'];
									// account for margin changes
									if ($page > $startpage) {
										if (($this->rtl) AND ($this->pagedim[$page]['orm'] != $this->pagedim[$startpage]['orm'])) {
											$this->x -= ($this->pagedim[$page]['orm'] - $this->pagedim[$startpage]['orm']);
										} elseif ((!$this->rtl) AND ($this->pagedim[$page]['lm'] != $this->pagedim[$startpage]['olm'])) {
											$this->x += ($this->pagedim[$page]['olm'] - $this->pagedim[$startpage]['olm']);
										}
									}
									// design a cell around the text
									$ccode = $this->FillColor."\n".$this->getCellCode($cw, $ch, '', $cborder, 1, '', $fill, '', 0, true);
									if ($cborder OR $fill) {
										$pagebuff = $this->getPageBuffer($this->page);
										$pstart = substr($pagebuff, 0, $this->intmrk[$this->page]);
										$pend = substr($pagebuff, $this->intmrk[$this->page]);
										$this->setPageBuffer($this->page, $pstart.$ccode."\n".$pend);
										$this->intmrk[$this->page] += strlen($ccode."\n");
									}
								}
							} else {
								$this->setPage($startpage);
								if (isset($cellpos['bgcolor']) AND ($cellpos['bgcolor']) !== false) {
									$this->SetFillColorArray($cellpos['bgcolor']);
									$fill = true;
								} else {
									$fill = false;
								}
								$this->x = $cellpos['startx'];
								$this->y = $parent['starty'];
								$cw = abs($cellpos['endx'] - $cellpos['startx']);
								$ch = $endy - $parent['starty'];
								// design a cell around the text
								$ccode = $this->FillColor."\n".$this->getCellCode($cw, $ch, '', $border, 1, '', $fill, '', 0, true);
								if ($border OR $fill) {
									if (end($this->transfmrk[$this->page]) !== false) {
										$pagemarkkey = key($this->transfmrk[$this->page]);
										$pagemark = &$this->transfmrk[$this->page][$pagemarkkey];
									} elseif ($this->InFooter) {
										$pagemark = &$this->footerpos[$this->page];
									} else {
										$pagemark = &$this->intmrk[$this->page];
									}
									$pagebuff = $this->getPageBuffer($this->page);
									$pstart = substr($pagebuff, 0, $pagemark);
									$pend = substr($pagebuff, $pagemark);
									$this->setPageBuffer($this->page, $pstart.$ccode."\n".$pend);
									$pagemark += strlen($ccode."\n");
								}
							}
						}
						if (isset($table_el['attribute']['cellspacing'])) {
							$cellspacing = $this->getHTMLUnitToUnits($table_el['attribute']['cellspacing'], 1, 'px');
							$this->y += $cellspacing;
						}
						$this->Ln(0, $cell);
						$this->x = $parent['startx'];
						if ($endpage > $startpage) {
							if (($this->rtl) AND ($this->pagedim[$endpage]['orm'] != $this->pagedim[$startpage]['orm'])) {
								$this->x += ($this->pagedim[$endpage]['orm'] - $this->pagedim[$startpage]['orm']);
							} elseif ((!$this->rtl) AND ($this->pagedim[$endpage]['olm'] != $this->pagedim[$startpage]['olm'])) {
								$this->x += ($this->pagedim[$endpage]['olm'] - $this->pagedim[$startpage]['olm']);
							}
						}
					}
					if (!$in_table_head) {
						// we are not inside a thead section
						if (isset($parent['cellpadding'])) {
							$this->cMargin = $this->oldcMargin;
						}
						$this->lasth = $this->FontSize * $this->cell_height_ratio;
						if (isset($this->theadMargins['top'])) {
							if (($this->theadMargins['top'] == $this->tMargin) AND ($this->page == ($this->numpages - 1))) {
								// remove last page containing only THEAD
								$this->deletePage($this->numpages);
							}
							// restore top margin
							$this->tMargin = $this->theadMargins['top'];
							$this->pagedim[$this->page]['tm'] = $this->tMargin;
						}
						if (!isset($table_el['attribute']['nested']) OR ($table_el['attribute']['nested'] != 'true')) {
							// reset main table header
							$this->thead = '';
							$this->theadMargins = array();
						}
					}
					break;
				}
				case 'a': {
					$this->HREF = '';
					break;
				}
				case 'sup': {
					$this->SetXY($this->GetX(), $this->GetY() + ((0.7 * $parent['fontsize']) / $this->k));
					break;
				}
				case 'sub': {
					$this->SetXY($this->GetX(), $this->GetY() - ((0.3 * $parent['fontsize'])/$this->k));
					break;
				}
				case 'div': {
					$this->addHTMLVertSpace($hbz, 0, $cell, $firstorlast);
					break;
				}
				case 'blockquote': {
					if ($this->rtl) {
						$this->rMargin -= $this->listindent;
					} else {
						$this->lMargin -= $this->listindent;
					}
					--$this->listindentlevel;
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					break;
				}
				case 'p': {
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					break;
				}
				case 'pre': {
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					$this->premode = false;
					break;
				}
				case 'dl': {
					--$this->listnum;
					if ($this->listnum <= 0) {
						$this->listnum = 0;
						$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					} else {
						$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					}
					$this->lasth = $this->FontSize * $this->cell_height_ratio;
					break;
				}
				case 'dt': {
					$this->lispacer = '';
					$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					break;
				}
				case 'dd': {
					$this->lispacer = '';
					if ($this->rtl) {
						$this->rMargin -= $this->listindent;
					} else {
						$this->lMargin -= $this->listindent;
					}
					--$this->listindentlevel;
					$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					break;
				}
				case 'ul':
				case 'ol': {
					--$this->listnum;
					$this->lispacer = '';
					if ($this->rtl) {
						$this->rMargin -= $this->listindent;
					} else {
						$this->lMargin -= $this->listindent;
					}
					--$this->listindentlevel;
					if ($this->listnum <= 0) {
						$this->listnum = 0;
						$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					} else {
						$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					}
					$this->lasth = $this->FontSize * $this->cell_height_ratio;
					break;
				}
				case 'li': {
					$this->lispacer = '';
					$this->addHTMLVertSpace(0, 0, $cell, $firstorlast);
					break;
				}
				case 'h1':
				case 'h2':
				case 'h3':
				case 'h4':
				case 'h5':
				case 'h6': {
					$this->addHTMLVertSpace($hbz, $hb, $cell, $firstorlast);
					break;
				}
				// Form fields (since 4.8.000 - 2009-09-07)
				case 'form': {
					$this->form_action = '';
					$this->form_enctype = 'application/x-www-form-urlencoded';
					break;
				}
				default : {
					break;
				}
			}
			if (isset($dom[($dom[$key]['parent'])]['attribute']['pagebreakafter'])) {
				$pba = $dom[($dom[$key]['parent'])]['attribute']['pagebreakafter'];
				// check for pagebreak
				if (($pba == 'true') OR ($pba == 'left') OR ($pba == 'right')) {
					// add a page (or trig AcceptPageBreak() for multicolumn mode)
					$this->checkPageBreak($this->PageBreakTrigger + 1);
				}
				if ((($pba == 'left') AND (((!$this->rtl) AND (($this->page % 2) == 0)) OR (($this->rtl) AND (($this->page % 2) != 0))))
					OR (($pba == 'right') AND (((!$this->rtl) AND (($this->page % 2) != 0)) OR (($this->rtl) AND (($this->page % 2) == 0))))) {
					// add a page (or trig AcceptPageBreak() for multicolumn mode)
					$this->checkPageBreak($this->PageBreakTrigger + 1);
				}
			}
			$this->tmprtl = false;
		}

		/**
		 * Add vertical spaces if needed.
		 * @param string $hbz Distance between current y and line bottom.
		 * @param string $hb The height of the break.
		 * @param boolean $cell if true add the default cMargin space to each new line (default false).
		 * @param boolean $firstorlast if true do not print additional empty lines.
		 * @access protected
		 */
		protected function addHTMLVertSpace($hbz=0, $hb=0, $cell=false, $firstorlast=false) {
			if ($firstorlast) {
				$this->Ln(0, $cell);
				$this->htmlvspace = 0;
				return;
			}
			if ($hb < $this->htmlvspace) {
				$hd = 0;
			} else {
				$hd = $hb - $this->htmlvspace;
				$this->htmlvspace = $hb;
			}
			$this->Ln(($hbz + $hd), $cell);
		}

		/**
		 * Set the default bullet to be used as LI bullet symbol
		 * @param string $symbol character or string to be used (legal values are: '' = automatic, '!' = auto bullet, '#' = auto numbering, 'disc', 'disc', 'circle', 'square', '1', 'decimal', 'decimal-leading-zero', 'i', 'lower-roman', 'I', 'upper-roman', 'a', 'lower-alpha', 'lower-latin', 'A', 'upper-alpha', 'upper-latin', 'lower-greek')
		 * @access public
		 * @since 4.0.028 (2008-09-26)
		 */
		public function setLIsymbol($symbol='!') {
			$symbol = strtolower($symbol);
			switch ($symbol) {
				case '!' :
				case '#' :
				case 'disc' :
				case 'circle' :
				case 'square' :
				case '1':
				case 'decimal':
				case 'decimal-leading-zero':
				case 'i':
				case 'lower-roman':
				case 'I':
				case 'upper-roman':
				case 'a':
				case 'lower-alpha':
				case 'lower-latin':
				case 'A':
				case 'upper-alpha':
				case 'upper-latin':
				case 'lower-greek': {
					$this->lisymbol = $symbol;
					break;
				}
				default : {
					$this->lisymbol = '';
				}
			}
		}

		/**
		 * Set the booklet mode for double-sided pages.
		 * @param boolean $booklet true set the booklet mode on, fals eotherwise.
		 * @param float $inner Inner page margin.
		 * @param float $outer Outer page margin.
		 * @access public
		 * @since 4.2.000 (2008-10-29)
		 */
		public function SetBooklet($booklet=true, $inner=-1, $outer=-1) {
			$this->booklet = $booklet;
			if ($inner >= 0) {
				$this->lMargin = $inner;
			}
			if ($outer >= 0) {
				$this->rMargin = $outer;
			}
		}

		/**
		 * Swap the left and right margins.
		 * @param boolean $reverse if true swap left and right margins.
		 * @access protected
		 * @since 4.2.000 (2008-10-29)
		 */
		protected function swapMargins($reverse=true) {
			if ($reverse) {
				// swap left and right margins
				$mtemp = $this->original_lMargin;
				$this->original_lMargin = $this->original_rMargin;
				$this->original_rMargin = $mtemp;
				$deltam = $this->original_lMargin - $this->original_rMargin;
				$this->lMargin += $deltam;
				$this->rMargin -= $deltam;
			}
		}

		/**
		 * Set the vertical spaces for HTML tags.
		 * The array must have the following structure (example):
		 * $tagvs = array('h1' => array(0 => array('h' => '', 'n' => 2), 1 => array('h' => 1.3, 'n' => 1)));
		 * The first array level contains the tag names,
		 * the second level contains 0 for opening tags or 1 for closing tags,
		 * the third level contains the vertical space unit (h) and the number spaces to add (n).
		 * If the h parameter is not specified, default values are used.
		 * @param array $tagvs array of tags and relative vertical spaces.
		 * @access public
		 * @since 4.2.001 (2008-10-30)
		 */
		public function setHtmlVSpace($tagvs) {
			$this->tagvspaces = $tagvs;
		}

        /**
		 * Set custom width for list indentation.
		 * @param float $width width of the indentation. Use negative value to disable it.
		 * @access public
		 * @since 4.2.007 (2008-11-12)
		 */
		public function setListIndentWidth($width) {
			return $this->customlistindent = floatval($width);
        }

        /**
		 * Set the top/bottom cell sides to be open or closed when the cell cross the page.
		 * @param boolean $isopen if true keeps the top/bottom border open for the cell sides that cross the page.
		 * @access public
		 * @since 4.2.010 (2008-11-14)
		 */
		public function setOpenCell($isopen) {
			$this->opencell = $isopen;
        }

        /**
		 * Set the color and font style for HTML links.
		 * @param array $color RGB array of colors
		 * @param string $fontstyle additional font styles to add
		 * @access public
		 * @since 4.4.003 (2008-12-09)
		 */
		public function setHtmlLinksStyle($color=array(0,0,255), $fontstyle='U') {
			$this->htmlLinkColorArray = $color;
			$this->htmlLinkFontStyle = $fontstyle;
        }

        /**
		 * Convert HTML string containing value and unit of measure to user's units or points.
		 * @param string $htmlval string containing values and unit
		 * @param string $refsize reference value in points
		 * @param string $defaultunit default unit (can be one of the following: %, em, ex, px, in, mm, pc, pt).
		 * @param boolean $point if true returns points, otherwise returns value in user's units
		 * @return float value in user's unit or point if $points=true
		 * @access public
		 * @since 4.4.004 (2008-12-10)
		 */
        public function getHTMLUnitToUnits($htmlval, $refsize=1, $defaultunit='px', $points=false) {
			$supportedunits = array('%', 'em', 'ex', 'px', 'in', 'cm', 'mm', 'pc', 'pt');
			$retval = 0;
			$value = 0;
			$unit = 'px';
			$k = $this->k;
			if ($points) {
				$k = 1;
			}
			if (in_array($defaultunit, $supportedunits)) {
				$unit = $defaultunit;
			}
			if (is_numeric($htmlval)) {
				$value = floatval($htmlval);
			} elseif (preg_match('/([0-9\.\-\+]+)/', $htmlval, $mnum)) {
				$value = floatval($mnum[1]);
				if (preg_match('/([a-z%]+)/', $htmlval, $munit)) {
					if (in_array($munit[1], $supportedunits)) {
						$unit = $munit[1];
					}
				}
			}
			switch ($unit) {
				// percentage
				case '%': {
					$retval = (($value * $refsize) / 100);
					break;
				}
				// relative-size
				case 'em': {
					$retval = ($value * $refsize);
					break;
				}
				case 'ex': {
					$retval = $value * ($refsize / 2);
					break;
				}
				// absolute-size
				case 'in': {
					$retval = ($value * $this->dpi) / $k;
					break;
				}
				case 'cm': {
					$retval = ($value / 2.54 * $this->dpi) / $k;
					break;
				}
				case 'mm': {
					$retval = ($value / 25.4 * $this->dpi) / $k;
					break;
				}
				case 'pc': {
					// one pica is 12 points
					$retval = ($value * 12) / $k;
					break;
				}
				case 'pt': {
					$retval = $value / $k;
					break;
				}
				case 'px': {
					$retval = $this->pixelsToUnits($value);
					break;
				}
			}
			return $retval;
		}

		/**
		 * Returns the Roman representation of an integer number
		 * @param int number to convert
		 * @return string roman representation of the specified number
		 * @access public
		 * @since 4.4.004 (2008-12-10)
		 */
		public function intToRoman($number) {
			$roman = '';
			while ($number >= 1000) {
				$roman .= 'M';
				$number -= 1000;
			}
			while ($number >= 900) {
				$roman .= 'CM';
				$number -= 900;
			}
			while ($number >= 500) {
				$roman .= 'D';
				$number -= 500;
			}
			while ($number >= 400) {
				$roman .= 'CD';
				$number -= 400;
			}
			while ($number >= 100) {
				$roman .= 'C';
				$number -= 100;
			}
			while ($number >= 90) {
				$roman .= 'XC';
				$number -= 90;
			}
			while ($number >= 50) {
				$roman .= 'L';
				$number -= 50;
			}
			while ($number >= 40) {
				$roman .= 'XL';
				$number -= 40;
			}
			while ($number >= 10) {
				$roman .= 'X';
				$number -= 10;
			}
			while ($number >= 9) {
				$roman .= 'IX';
				$number -= 9;
			}
			while ($number >= 5) {
				$roman .= 'V';
				$number -= 5;
			}
			while ($number >= 4) {
				$roman .= 'IV';
				$number -= 4;
			}
			while ($number >= 1) {
				$roman .= 'I';
				--$number;
			}
			return $roman;
		}

		/**
		 * Output an HTML list bullet or ordered item symbol
		 * @param int $listdepth list nesting level
		 * @param string $listtype type of list
		 * @param float $size current font size
		 * @access protected
		 * @since 4.4.004 (2008-12-10)
		 */
		protected function putHtmlListBullet($listdepth, $listtype='', $size=10) {
			$size /= $this->k;
			$fill = '';
			$color = $this->fgcolor;
			$width = 0;
			$textitem = '';
			$tmpx = $this->x;
			$lspace = $this->GetStringWidth('  ');
			if ($listtype == '!') {
				// set default list type for unordered list
				$deftypes = array('disc', 'circle', 'square');
				$listtype = $deftypes[($listdepth - 1) % 3];
			} elseif ($listtype == '#') {
				// set default list type for ordered list
				$listtype = 'decimal';
			}
        	switch ($listtype) {
        		// unordered types
				case 'none': {
					break;
				}
				case 'disc': {
					$fill = 'F';
				}
				case 'circle': {
					$fill .= 'D';
					$r = $size / 6;
					$lspace += (2 * $r);
					if ($this->rtl) {
						$this->x += $lspace;
					} else {
						$this->x -= $lspace;
					}
					$this->Circle(($this->x + $r), ($this->y + ($this->lasth / 2)), $r, 0, 360, $fill, array('color'=>$color), $color, 8);
					break;
				}
				case 'square': {
					$l = $size / 3;
					$lspace += $l;
					if ($this->rtl) {;
						$this->x += $lspace;
					} else {
						$this->x -= $lspace;
					}
					$this->Rect($this->x, ($this->y + (($this->lasth - $l)/ 2)), $l, $l, 'F', array(), $color);
					break;
				}
				// ordered types
				// $this->listcount[$this->listnum];
				// $textitem
				case '1':
				case 'decimal': {
					$textitem = $this->listcount[$this->listnum];
					break;
				}
				case 'decimal-leading-zero': {
					$textitem = sprintf('%02d', $this->listcount[$this->listnum]);
					break;
				}
				case 'i':
				case 'lower-roman': {
					$textitem = strtolower($this->intToRoman($this->listcount[$this->listnum]));
					break;
				}
				case 'I':
				case 'upper-roman': {
					$textitem = $this->intToRoman($this->listcount[$this->listnum]);
					break;
				}
				case 'a':
				case 'lower-alpha':
				case 'lower-latin': {
					$textitem = chr(97 + $this->listcount[$this->listnum] - 1);
					break;
				}
				case 'A':
				case 'upper-alpha':
				case 'upper-latin': {
					$textitem = chr(65 + $this->listcount[$this->listnum] - 1);
					break;
				}
				case 'lower-greek': {
					$textitem = $this->unichr(945 + $this->listcount[$this->listnum] - 1);
					break;
				}
				/*
				// Types to be implemented (special handling)
				case 'hebrew': {
					break;
				}
				case 'armenian': {
					break;
				}
				case 'georgian': {
					break;
				}
				case 'cjk-ideographic': {
					break;
				}
				case 'hiragana': {
					break;
				}
				case 'katakana': {
					break;
				}
				case 'hiragana-iroha': {
					break;
				}
				case 'katakana-iroha': {
					break;
				}
				*/
				default: {
					$textitem = $this->listcount[$this->listnum];
				}
			}
			if (!$this->empty_string($textitem)) {
				// print ordered item
				if ($this->rtl) {
					$textitem = '.'.$textitem;
				} else {
					$textitem = $textitem.'.';
				}
				$lspace += $this->GetStringWidth($textitem);
				if ($this->rtl) {
					$this->x += $lspace;
				} else {
					$this->x -= $lspace;
				}
				$this->Write($this->lasth, $textitem, '', false, '', false, 0, false);
			}
			$this->x = $tmpx;
			$this->lispacer = '';
		}

        /**
		 * Returns current graphic variables as array.
		 * @return array graphic variables
		 * @access protected
		 * @since 4.2.010 (2008-11-14)
		 */
		protected function getGraphicVars() {
			$grapvars = array(
				'FontFamily' => $this->FontFamily,
				'FontStyle' => $this->FontStyle,
				'FontSizePt' => $this->FontSizePt,
				'rMargin' => $this->rMargin,
				'lMargin' => $this->lMargin,
				'cMargin' => $this->cMargin,
				'LineWidth' => $this->LineWidth,
				'linestyleWidth' => $this->linestyleWidth,
				'linestyleCap' => $this->linestyleCap,
				'linestyleJoin' => $this->linestyleJoin,
				'linestyleDash' => $this->linestyleDash,
				'textrendermode' => $this->textrendermode,
				'textstrokewidth' => $this->textstrokewidth,
				'DrawColor' => $this->DrawColor,
				'FillColor' => $this->FillColor,
				'TextColor' => $this->TextColor,
				'ColorFlag' => $this->ColorFlag,
				'bgcolor' => $this->bgcolor,
				'fgcolor' => $this->fgcolor,
				'htmlvspace' => $this->htmlvspace,
				'lasth' => $this->lasth
				);
			return $grapvars;
		}

        /**
		 * Set graphic variables.
		 * @param $gvars array graphic variables
		 * @access protected
		 * @since 4.2.010 (2008-11-14)
		 */
		protected function setGraphicVars($gvars) {
			$this->FontFamily = $gvars['FontFamily'];
			$this->FontStyle = $gvars['FontStyle'];
			$this->FontSizePt = $gvars['FontSizePt'];
			$this->rMargin = $gvars['rMargin'];
			$this->lMargin = $gvars['lMargin'];
			$this->cMargin = $gvars['cMargin'];
			$this->LineWidth = $gvars['LineWidth'];
			$this->linestyleWidth = $gvars['linestyleWidth'];
			$this->linestyleCap = $gvars['linestyleCap'];
			$this->linestyleJoin = $gvars['linestyleJoin'];
			$this->linestyleDash = $gvars['linestyleDash'];
			$this->textrendermode = $gvars['textrendermode'];
			$this->textstrokewidth = $gvars['textstrokewidth'];
			$this->DrawColor = $gvars['DrawColor'];
			$this->FillColor = $gvars['FillColor'];
			$this->TextColor = $gvars['TextColor'];
			$this->ColorFlag = $gvars['ColorFlag'];
			$this->bgcolor = $gvars['bgcolor'];
			$this->fgcolor = $gvars['fgcolor'];
			$this->htmlvspace = $gvars['htmlvspace'];
			//$this->lasth = $gvars['lasth'];
			$this->_out(''.$this->linestyleWidth.' '.$this->linestyleCap.' '.$this->linestyleJoin.' '.$this->linestyleDash.' '.$this->DrawColor.' '.$this->FillColor.'');
			if (!$this->empty_string($this->FontFamily)) {
				$this->SetFont($this->FontFamily, $this->FontStyle, $this->FontSizePt);
			}
		}

		/**
		 * Returns a temporary filename for caching object on filesystem.
		 * @param string $prefix prefix to add to filename
		 * return string filename.
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function getObjFilename($name) {
			return tempnam(K_PATH_CACHE, $name.'_');
		}

        /**
		 * Writes data to a temporary file on filesystem.
		 * @param string $file file name
		 * @param mixed $data data to write on file
		 * @param boolean $append if true append data, false replace.
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function writeDiskCache($filename, $data, $append=false) {
			if ($append) {
				$fmode = 'ab+';
			} else {
				$fmode = 'wb+';
			}
			$f = @fopen($filename, $fmode);
			if (!$f) {
				$this->Error('Unable to write cache file: '.$filename);
			} else {
				fwrite($f, $data);
				fclose($f);
			}
			// update file length (needed for transactions)
			if (!isset($this->cache_file_length['_'.$filename])) {
				$this->cache_file_length['_'.$filename] = strlen($data);
			} else {
				$this->cache_file_length['_'.$filename] += strlen($data);
			}
		}

        /**
		 * Read data from a temporary file on filesystem.
		 * @param string $file file name
		 * @return mixed retrieved data
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function readDiskCache($filename) {
			return file_get_contents($filename);
		}

		/**
		 * Set buffer content (always append data).
		 * @param string $data data
		 * @access protected
		 * @since 4.5.000 (2009-01-02)
		 */
		protected function setBuffer($data) {
			$this->bufferlen += strlen($data);
			if ($this->diskcache) {
				if (!isset($this->buffer) OR $this->empty_string($this->buffer)) {
					$this->buffer = $this->getObjFilename('buffer');
				}
				$this->writeDiskCache($this->buffer, $data, true);
			} else {
				$this->buffer .= $data;
			}
		}

        /**
		 * Get buffer content.
		 * @return string buffer content
		 * @access protected
		 * @since 4.5.000 (2009-01-02)
		 */
		protected function getBuffer() {
			if ($this->diskcache) {
				return $this->readDiskCache($this->buffer);
			} else {
				return $this->buffer;
			}
		}

        /**
		 * Set page buffer content.
		 * @param int $page page number
		 * @param string $data page data
		 * @param boolean $append if true append data, false replace.
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function setPageBuffer($page, $data, $append=false) {
			if ($this->diskcache) {
				if (!isset($this->pages[$page])) {
					$this->pages[$page] = $this->getObjFilename('page'.$page);
				}
				$this->writeDiskCache($this->pages[$page], $data, $append);
			} else {
				if ($append) {
					$this->pages[$page] .= $data;
				} else {
					$this->pages[$page] = $data;
				}
			}
			if ($append AND isset($this->pagelen[$page])) {
				$this->pagelen[$page] += strlen($data);
			} else {
				$this->pagelen[$page] = strlen($data);
			}
		}

        /**
		 * Get page buffer content.
		 * @param int $page page number
		 * @return string page buffer content or false in case of error
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function getPageBuffer($page) {
			if ($this->diskcache) {
				return $this->readDiskCache($this->pages[$page]);
			} elseif (isset($this->pages[$page])) {
				return $this->pages[$page];
			}
			return false;
		}

        /**
		 * Set image buffer content.
		 * @param string $image image key
		 * @param array $data image data
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function setImageBuffer($image, $data) {
			if ($this->diskcache) {
				if (!isset($this->images[$image])) {
					$this->images[$image] = $this->getObjFilename('image'.$image);
				}
				$this->writeDiskCache($this->images[$image], serialize($data));
			} else {
				$this->images[$image] = $data;
			}
			if (!in_array($image, $this->imagekeys)) {
				$this->imagekeys[] = $image;
				++$this->numimages;
			}
		}

        /**
		 * Set image buffer content for a specified sub-key.
		 * @param string $image image key
		 * @param string $key image sub-key
		 * @param array $data image data
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function setImageSubBuffer($image, $key, $data) {
			if (!isset($this->images[$image])) {
				$this->setImageBuffer($image, array());
			}
			if ($this->diskcache) {
				$tmpimg = $this->getImageBuffer($image);
				$tmpimg[$key] = $data;
				$this->writeDiskCache($this->images[$image], serialize($tmpimg));
			} else {
				$this->images[$image][$key] = $data;
			}
		}

        /**
		 * Get image buffer content.
		 * @param string $image image key
		 * @return string image buffer content or false in case of error
		 * @access protected
		 * @since 4.5.000 (2008-12-31)
		 */
		protected function getImageBuffer($image) {
			if ($this->diskcache AND isset($this->images[$image])) {
				return unserialize($this->readDiskCache($this->images[$image]));
			} elseif (isset($this->images[$image])) {
				return $this->images[$image];
			}
			return false;
		}

		/**
		 * Set font buffer content.
		 * @param string $font font key
		 * @param array $data font data
		 * @access protected
		 * @since 4.5.000 (2009-01-02)
		 */
		protected function setFontBuffer($font, $data) {
			if ($this->diskcache) {
				if (!isset($this->fonts[$font])) {
					$this->fonts[$font] = $this->getObjFilename('font');
				}
				$this->writeDiskCache($this->fonts[$font], serialize($data));
			} else {
				$this->fonts[$font] = $data;
			}
			if (!in_array($font, $this->fontkeys)) {
				$this->fontkeys[] = $font;
			}
		}

        /**
		 * Set font buffer content.
		 * @param string $font font key
		 * @param string $key font sub-key
		 * @param array $data font data
		 * @access protected
		 * @since 4.5.000 (2009-01-02)
		 */
		protected function setFontSubBuffer($font, $key, $data) {
			if (!isset($this->fonts[$font])) {
				$this->setFontBuffer($font, array());
			}
			if ($this->diskcache) {
				$tmpfont = $this->getFontBuffer($font);
				$tmpfont[$key] = $data;
				$this->writeDiskCache($this->fonts[$font], serialize($tmpfont));
			} else {
				$this->fonts[$font][$key] = $data;
			}
		}

        /**
		 * Get font buffer content.
		 * @param string $font font key
		 * @return string font buffer content or false in case of error
		 * @access protected
		 * @since 4.5.000 (2009-01-02)
		 */
		protected function getFontBuffer($font) {
			if ($this->diskcache AND isset($this->fonts[$font])) {
				return unserialize($this->readDiskCache($this->fonts[$font]));
			} elseif (isset($this->fonts[$font])) {
				return $this->fonts[$font];
			}
			return false;
		}

		/**
		 * Move a page to a previous position.
		 * @param int $frompage number of the source page
		 * @param int $topage number of the destination page (must be less than $frompage)
		 * @return true in case of success, false in case of error.
		 * @access public
		 * @since 4.5.000 (2009-01-02)
		 */
		public function movePage($frompage, $topage) {
			if (($frompage > $this->numpages) OR ($frompage <= $topage)) {
				return false;
			}
			if ($frompage == $this->page) {
				// close the page before moving it
				$this->endPage();
			}
			// move all page-related states
			$tmppage = $this->pages[$frompage];
			$tmppagedim = $this->pagedim[$frompage];
			$tmppagelen = $this->pagelen[$frompage];
			$tmpintmrk = $this->intmrk[$frompage];
			if (isset($this->footerpos[$frompage])) {
				$tmpfooterpos = $this->footerpos[$frompage];
			}
			if (isset($this->footerlen[$frompage])) {
				$tmpfooterlen = $this->footerlen[$frompage];
			}
			if (isset($this->transfmrk[$frompage])) {
				$tmptransfmrk = $this->transfmrk[$frompage];
			}
			if (isset($this->PageAnnots[$frompage])) {
				$tmpannots = $this->PageAnnots[$frompage];
			}
			if (isset($this->newpagegroup[$frompage])) {
				$tmpnewpagegroup = $this->newpagegroup[$frompage];
			}
			for ($i = $frompage; $i > $topage; --$i) {
				$j = $i - 1;
				// shift pages down
				$this->pages[$i] = $this->pages[$j];
				$this->pagedim[$i] = $this->pagedim[$j];
				$this->pagelen[$i] = $this->pagelen[$j];
				$this->intmrk[$i] = $this->intmrk[$j];
				if (isset($this->footerpos[$j])) {
					$this->footerpos[$i] = $this->footerpos[$j];
				} elseif (isset($this->footerpos[$i])) {
					unset($this->footerpos[$i]);
				}
				if (isset($this->footerlen[$j])) {
					$this->footerlen[$i] = $this->footerlen[$j];
				} elseif (isset($this->footerlen[$i])) {
					unset($this->footerlen[$i]);
				}
				if (isset($this->transfmrk[$j])) {
					$this->transfmrk[$i] = $this->transfmrk[$j];
				} elseif (isset($this->transfmrk[$i])) {
					unset($this->transfmrk[$i]);
				}
				if (isset($this->PageAnnots[$j])) {
					$this->PageAnnots[$i] = $this->PageAnnots[$j];
				} elseif (isset($this->PageAnnots[$i])) {
					unset($this->PageAnnots[$i]);
				}
				if (isset($this->newpagegroup[$j])) {
					$this->newpagegroup[$i] = $this->newpagegroup[$j];
				} elseif (isset($this->newpagegroup[$i])) {
					unset($this->newpagegroup[$i]);
				}
			}
			$this->pages[$topage] = $tmppage;
			$this->pagedim[$topage] = $tmppagedim;
			$this->pagelen[$topage] = $tmppagelen;
			$this->intmrk[$topage] = $tmpintmrk;
			if (isset($tmpfooterpos)) {
				$this->footerpos[$topage] = $tmpfooterpos;
			} elseif (isset($this->footerpos[$topage])) {
				unset($this->footerpos[$topage]);
			}
			if (isset($tmpfooterlen)) {
				$this->footerlen[$topage] = $tmpfooterlen;
			} elseif (isset($this->footerlen[$topage])) {
				unset($this->footerlen[$topage]);
			}
			if (isset($tmptransfmrk)) {
				$this->transfmrk[$topage] = $tmptransfmrk;
			} elseif (isset($this->transfmrk[$topage])) {
				unset($this->transfmrk[$topage]);
			}
			if (isset($tmpannots)) {
				$this->PageAnnots[$topage] = $tmpannots;
			} elseif (isset($this->PageAnnots[$topage])) {
				unset($this->PageAnnots[$topage]);
			}
			if (isset($tmpnewpagegroup)) {
				$this->newpagegroup[$topage] = $tmpnewpagegroup;
			} elseif (isset($this->newpagegroup[$topage])) {
				unset($this->newpagegroup[$topage]);
			}
			// adjust outlines
			$tmpoutlines = $this->outlines;
			foreach ($tmpoutlines as $key => $outline) {
				if (($outline['p'] >= $topage) AND ($outline['p'] < $frompage)) {
					$this->outlines[$key]['p'] = $outline['p'] + 1;
				} elseif ($outline['p'] == $frompage) {
					$this->outlines[$key]['p'] = $topage;
				}
			}
			// adjust links
			$tmplinks = $this->links;
			foreach ($tmplinks as $key => $link) {
				if (($link[0] >= $topage) AND ($link[0] < $frompage)) {
					$this->links[$key][0] = $link[0] + 1;
				} elseif ($link[0] == $frompage) {
					$this->links[$key][0] = $topage;
				}
			}
			// adjust javascript
			$tmpjavascript = $this->javascript;
			global $jfrompage, $jtopage;
			$jfrompage = $frompage;
			$jtopage = $topage;
			$this->javascript = preg_replace_callback('/this\.addField\(\'([^\']*)\',\'([^\']*)\',([0-9]+)/',
				create_function('$matches', 'global $jfrompage, $jtopage;
				$pagenum = intval($matches[3]) + 1;
				if (($pagenum >= $jtopage) AND ($pagenum < $jfrompage)) {
					$newpage = ($pagenum + 1);
				} elseif ($pagenum == $jfrompage) {
					$newpage = $jtopage;
				} else {
					$newpage = $pagenum;
				}
				--$newpage;
				return "this.addField(\'".$matches[1]."\',\'".$matches[2]."\',".$newpage."";'), $tmpjavascript);
			// return to last page
			$this->lastPage(true);
			return true;
		}

        /**
		 * Remove the specified page.
		 * @param int $page page to remove
		 * @return true in case of success, false in case of error.
		 * @access public
		 * @since 4.6.004 (2009-04-23)
		 */
		public function deletePage($page) {
			if ($page > $this->numpages) {
				return false;
			}
			// delete current page
			unset($this->pages[$page]);
			unset($this->pagedim[$page]);
			unset($this->pagelen[$page]);
			unset($this->intmrk[$page]);
			if (isset($this->footerpos[$page])) {
				unset($this->footerpos[$page]);
			}
			if (isset($this->footerlen[$page])) {
				unset($this->footerlen[$page]);
			}
			if (isset($this->transfmrk[$page])) {
				unset($this->transfmrk[$page]);
			}
			if (isset($this->PageAnnots[$page])) {
				unset($this->PageAnnots[$page]);
			}
			if (isset($this->newpagegroup[$page])) {
				unset($this->newpagegroup[$page]);
			}
			if (isset($this->pageopen[$page])) {
				unset($this->pageopen[$page]);
			}
			// update remaining pages
			for ($i = $page; $i < $this->numpages; ++$i) {
				$j = $i + 1;
				// shift pages
				$this->pages[$i] = $this->pages[$j];
				$this->pagedim[$i] = $this->pagedim[$j];
				$this->pagelen[$i] = $this->pagelen[$j];
				$this->intmrk[$i] = $this->intmrk[$j];
				if (isset($this->footerpos[$j])) {
					$this->footerpos[$i] = $this->footerpos[$j];
				} elseif (isset($this->footerpos[$i])) {
					unset($this->footerpos[$i]);
				}
				if (isset($this->footerlen[$j])) {
					$this->footerlen[$i] = $this->footerlen[$j];
				} elseif (isset($this->footerlen[$i])) {
					unset($this->footerlen[$i]);
				}
				if (isset($this->transfmrk[$j])) {
					$this->transfmrk[$i] = $this->transfmrk[$j];
				} elseif (isset($this->transfmrk[$i])) {
					unset($this->transfmrk[$i]);
				}
				if (isset($this->PageAnnots[$j])) {
					$this->PageAnnots[$i] = $this->PageAnnots[$j];
				} elseif (isset($this->PageAnnots[$i])) {
					unset($this->PageAnnots[$i]);
				}
				if (isset($this->newpagegroup[$j])) {
					$this->newpagegroup[$i] = $this->newpagegroup[$j];
				} elseif (isset($this->newpagegroup[$i])) {
					unset($this->newpagegroup[$i]);
				}
				if (isset($this->pageopen[$j])) {
					$this->pageopen[$i] = $this->pageopen[$j];
				} elseif (isset($this->pageopen[$i])) {
					unset($this->pageopen[$i]);
				}
			}
			// remove last page
			unset($this->pages[$this->numpages]);
			unset($this->pagedim[$this->numpages]);
			unset($this->pagelen[$this->numpages]);
			unset($this->intmrk[$this->numpages]);
			if (isset($this->footerpos[$this->numpages])) {
				unset($this->footerpos[$this->numpages]);
			}
			if (isset($this->footerlen[$this->numpages])) {
				unset($this->footerlen[$this->numpages]);
			}
			if (isset($this->transfmrk[$this->numpages])) {
				unset($this->transfmrk[$this->numpages]);
			}
			if (isset($this->PageAnnots[$this->numpages])) {
				unset($this->PageAnnots[$this->numpages]);
			}
			if (isset($this->newpagegroup[$this->numpages])) {
				unset($this->newpagegroup[$this->numpages]);
			}
			if (isset($this->pageopen[$this->numpages])) {
				unset($this->pageopen[$this->numpages]);
			}
			--$this->numpages;
			$this->page = $this->numpages;
			// adjust outlines
			$tmpoutlines = $this->outlines;
			foreach ($tmpoutlines as $key => $outline) {
				if ($outline['p'] > $page) {
					$this->outlines[$key]['p'] = $outline['p'] - 1;
				} elseif ($outline['p'] == $page) {
					unset($this->outlines[$key]);
				}
			}
			// adjust links
			$tmplinks = $this->links;
			foreach ($tmplinks as $key => $link) {
				if ($link[0] > $page) {
					$this->links[$key][0] = $link[0] - 1;
				} elseif ($link[0] == $page) {
					unset($this->links[$key]);
				}
			}
			// adjust javascript
			$tmpjavascript = $this->javascript;
			global $jpage;
			$jpage = $page;
			$this->javascript = preg_replace_callback('/this\.addField\(\'([^\']*)\',\'([^\']*)\',([0-9]+)/',
				create_function('$matches', 'global $jpage;
				$pagenum = intval($matches[3]) + 1;
				if ($pagenum >= $jpage) {
					$newpage = ($pagenum - 1);
				} elseif ($pagenum == $jpage) {
					$newpage = 1;
				} else {
					$newpage = $pagenum;
				}
				--$newpage;
				return "this.addField(\'".$matches[1]."\',\'".$matches[2]."\',".$newpage."";'), $tmpjavascript);
			// return to last page
			$this->lastPage(true);
			return true;
		}

		/**
		 * Clone the specified page to a new page.
		 * @param int $page number of page to copy (0 = current page)
		 * @return true in case of success, false in case of error.
		 * @access public
		 * @since 4.9.015 (2010-04-20)
		 */
		public function copyPage($page=0) {
			if ($page == 0) {
				// default value
				$page = $this->page;
			}
			if ($page > $this->numpages) {
				return false;
			}
			if ($page == $this->page) {
				// close the page before cloning it
				$this->endPage();
			}
			// copy all page-related states
			++$this->numpages;
			$this->page = $this->numpages;
			$this->pages[$this->page] = $this->pages[$page];
			$this->pagedim[$this->page] = $this->pagedim[$page];
			$this->pagelen[$this->page] = $this->pagelen[$page];
			$this->intmrk[$this->page] = $this->intmrk[$page];
			$this->pageopen[$this->page] = false;
			if (isset($this->footerpos[$page])) {
				$this->footerpos[$this->page] = $this->footerpos[$page];
			}
			if (isset($this->footerlen[$page])) {
				$this->footerlen[$this->page] = $this->footerlen[$page];
			}
			if (isset($this->transfmrk[$page])) {
				$this->transfmrk[$this->page] = $this->transfmrk[$page];
			}
			if (isset($this->PageAnnots[$page])) {
				$this->PageAnnots[$this->page] = $this->PageAnnots[$page];
			}
			if (isset($this->newpagegroup[$page])) {
				$this->newpagegroup[$this->page] = $this->newpagegroup[$page];
			}
			// copy outlines
			$tmpoutlines = $this->outlines;
			foreach ($tmpoutlines as $key => $outline) {
				if ($outline['p'] == $page) {
					$this->outlines[] = array('t' => $outline['t'], 'l' => $outline['l'], 'y' => $outline['y'], 'p' => $this->page);
				}
			}
			// copy links
			$tmplinks = $this->links;
			foreach ($tmplinks as $key => $link) {
				if ($link[0] == $page) {
					$this->links[] = array($this->page, $link[1]);
				}
			}
			// return to last page
			$this->lastPage(true);
			return true;
		}

		/**
		 * Output a Table of Content Index (TOC).
		 * Before calling this method you have to open the page using the addTOCPage() method.
		 * After calling this method you have to call endTOCPage() to close the TOC page.
		 * You can override this method to achieve different styles.
		 * @param int $page page number where this TOC should be inserted (leave empty for current page).
		 * @param string $numbersfont set the font for page numbers (please use monospaced font for better alignment).
		 * @param string $filler string used to fill the space between text and page number.
		 * @param string $toc_name name to use for TOC bookmark.
		 * @access public
		 * @author Nicola Asuni
		 * @since 4.5.000 (2009-01-02)
		 * @see addTOCPage(), endTOCPage(), addHTMLTOC()
		 */
		public function addTOC($page='', $numbersfont='', $filler='.', $toc_name='TOC') {
			$fontsize = $this->FontSizePt;
			$fontfamily = $this->FontFamily;
			$fontstyle = $this->FontStyle;
			$w = $this->w - $this->lMargin - $this->rMargin;
			$spacer = $this->GetStringWidth(chr(32)) * 4;
			$page_first = $this->getPage();
			$lmargin = $this->lMargin;
			$rmargin = $this->rMargin;
			$x_start = $this->GetX();
			if ($this->empty_string($numbersfont)) {
				$numbersfont = $this->default_monospaced_font;
			}
			if ($this->empty_string($filler)) {
				$filler = ' ';
			}
			if ($this->empty_string($page)) {
				$gap = ' ';
			} else {
				$gap = '';
			}
			foreach ($this->outlines as $key => $outline) {
				if ($this->rtl) {
					$aligntext = 'R';
					$alignnum = 'L';
				} else {
					$aligntext = 'L';
					$alignnum = 'R';
				}
				if ($outline['l'] == 0) {
					$this->SetFont($fontfamily, $fontstyle.'B', $fontsize);
				} else {
					$this->SetFont($fontfamily, $fontstyle, $fontsize - $outline['l']);
				}
				$indent = ($spacer * $outline['l']);
				if ($this->rtl) {
					$this->rMargin += $indent;
					$this->x -= $indent;
				} else {
					$this->lMargin += $indent;
					$this->x += $indent;
				}
				$link = $this->AddLink();
				$this->SetLink($link, 0, $outline['p']);
				// write the text
				$this->Write(0, $outline['t'], $link, 0, $aligntext, false, 0, false, false, 0);
				$this->SetFont($numbersfont, $fontstyle, $fontsize);
				if ($this->empty_string($page)) {
					$pagenum = $outline['p'];
				} else {
					// placemark to be replaced with the correct number
					$pagenum = '{#'.($outline['p']).'}';
					if (($this->CurrentFont['type'] == 'TrueTypeUnicode') OR ($this->CurrentFont['type'] == 'cidfont0')) {
						$pagenum = '{'.$pagenum.'}';
					}
				}
				$numwidth = $this->GetStringWidth($pagenum);
				if ($this->rtl) {
					$tw = $this->x - $this->lMargin;
				} else {
					$tw = $this->w - $this->rMargin - $this->x;
				}
				$fw = $tw - $numwidth - $this->GetStringWidth(chr(32));
				$numfills = floor($fw / $this->GetStringWidth($filler));
				if ($numfills > 0) {
					$rowfill = str_repeat($filler, $numfills);
				} else {
					$rowfill = '';
				}
				if ($this->rtl) {
					$pagenum = $pagenum.$gap.$rowfill.' ';
				} else {
					$pagenum = ' '.$rowfill.$gap.$pagenum;
				}
				// write the number
				$this->Cell($tw, 0, $pagenum, 0, 1, $alignnum, 0, $link, 0);
				$this->SetX($x_start);
				$this->lMargin = $lmargin;
				$this->rMargin = $rmargin;
			}
			$page_last = $this->getPage();
			$numpages = $page_last - $page_first + 1;
			if (!$this->empty_string($page)) {
				for ($p = $page_first; $p <= $page_last; ++$p) {
					// get page data
					$temppage = $this->getPageBuffer($p);
					for ($n = 1; $n <= $this->numpages; ++$n) {
						// update page numbers
						$k = '{#'.$n.'}';
						$ku = '{'.$k.'}';
						$alias_a = $this->_escape($k);
						$alias_au = $this->_escape('{'.$k.'}');
						if ($this->isunicode) {
							$alias_b = $this->_escape($this->UTF8ToLatin1($k));
							$alias_bu = $this->_escape($this->UTF8ToLatin1($ku));
							$alias_c = $this->_escape($this->utf8StrRev($k, false, $this->tmprtl));
							$alias_cu = $this->_escape($this->utf8StrRev($ku, false, $this->tmprtl));
						}
						if ($n >= $page) {
							$np = $n + $numpages;
						} else {
							$np = $n;
						}
						$ns = $this->formatTOCPageNumber($np);
						$nu = $ns;
						$sdiff = strlen($k) - strlen($ns) - 1;
						$sdiffu = strlen($ku) - strlen($ns) - 1;
						$sfill = str_repeat($filler, $sdiff);
						$sfillu = str_repeat($filler, $sdiffu);
						if ($this->rtl) {
							$ns = $ns.' '.$sfill;
							$nu = $nu.' '.$sfillu;
						} else {
							$ns = $sfill.' '.$ns;
							$nu = $sfillu.' '.$nu;
						}
						$nu = $this->UTF8ToUTF16BE($nu, false);
						$temppage = str_replace($alias_au, $nu, $temppage);
						if ($this->isunicode) {
							$temppage = str_replace($alias_bu, $nu, $temppage);
							$temppage = str_replace($alias_cu, $nu, $temppage);
							$temppage = str_replace($alias_b, $ns, $temppage);
							$temppage = str_replace($alias_c, $ns, $temppage);
						}
						$temppage = str_replace($alias_a, $ns, $temppage);
					}
					// save changes
					$this->setPageBuffer($p, $temppage);
				}
				// move pages
				$this->Bookmark($toc_name, 0, 0, $page_first);
				for ($i = 0; $i < $numpages; ++$i) {
					$this->movePage($page_last, $page);
				}
			}
		}

		/**
		 * Output a Table Of Content Index (TOC) using HTML templates.
		 * Before calling this method you have to open the page using the addTOCPage() method.
		 * After calling this method you have to call endTOCPage() to close the TOC page.
		 * @param int $page page number where this TOC should be inserted (leave empty for current page).
		 * @param string $toc_name name to use for TOC bookmark.
		 * @param array $templates array of html templates. Use: #TOC_DESCRIPTION# for bookmark title, #TOC_PAGE_NUMBER# for page number.
		 * @parma boolean $correct_align if true correct the number alignment (numbers must be in monospaced font like courier and right aligned on LTR, or left aligned on RTL)
		 * @access public
		 * @author Nicola Asuni
		 * @since 5.0.001 (2010-05-06)
		 * @see addTOCPage(), endTOCPage(), addTOC()
		 */
		public function addHTMLTOC($page='', $toc_name='TOC', $templates=array(), $correct_align=true) {
			$prev_htmlLinkColorArray = $this->htmlLinkColorArray;
			$prev_htmlLinkFontStyle = $this->htmlLinkFontStyle;
			// set new style for link
			$this->htmlLinkColorArray = array();
			$this->htmlLinkFontStyle = '';
			$page_first = $this->getPage();
			foreach ($this->outlines as $key => $outline) {
				if ($this->empty_string($page)) {
					$pagenum = $outline['p'];
				} else {
					// placemark to be replaced with the correct number
					$pagenum = '{#'.($outline['p']).'}';
					if (($this->CurrentFont['type'] == 'TrueTypeUnicode') OR ($this->CurrentFont['type'] == 'cidfont0')) {
						$pagenum = '{'.$pagenum.'}';
					}
				}
				// get HTML template
				$row = $templates[$outline['l']];
				// replace templates with current values
				$row = str_replace('#TOC_DESCRIPTION#', $outline['t'], $row);
				$row = str_replace('#TOC_PAGE_NUMBER#', $pagenum, $row);
				// add link to page
				$row = ''.$row.'';
				// write bookmark entry
				$this->writeHTML($row, false, false, true, false, '');
			}
			// restore link styles
			$this->htmlLinkColorArray = $prev_htmlLinkColorArray;
			$this->htmlLinkFontStyle = $prev_htmlLinkFontStyle;
			// move TOC page and replace numbers
			$page_last = $this->getPage();
			$numpages = $page_last - $page_first + 1;
			if (!$this->empty_string($page)) {
				for ($p = $page_first; $p <= $page_last; ++$p) {
					// get page data
					$temppage = $this->getPageBuffer($p);
					for ($n = 1; $n <= $this->numpages; ++$n) {
						// update page numbers
						$k = '{#'.$n.'}';
						$ku = '{'.$k.'}';
						$alias_a = $this->_escape($k);
						$alias_au = $this->_escape('{'.$k.'}');
						if ($this->isunicode) {
							$alias_b = $this->_escape($this->UTF8ToLatin1($k));
							$alias_bu = $this->_escape($this->UTF8ToLatin1($ku));
							$alias_c = $this->_escape($this->utf8StrRev($k, false, $this->tmprtl));
							$alias_cu = $this->_escape($this->utf8StrRev($ku, false, $this->tmprtl));
						}
						if ($n >= $page) {
							$np = $n + $numpages;
						} else {
							$np = $n;
						}
						$ns = $this->formatTOCPageNumber($np);
						$nu = $ns;
						if ($correct_align) {
							$sdiff = strlen($k) - strlen($ns);
							$sdiffu = strlen($ku) - strlen($ns);
							$sfill = str_repeat(' ', $sdiff);
							$sfillu = str_repeat(' ', $sdiffu);
							if ($this->rtl) {
								$ns = $ns.$sfill;
								$nu = $nu.$sfillu;
							} else {
								$ns = $sfill.$ns;
								$nu = $sfillu.$nu;
							}
						}
						$nu = $this->UTF8ToUTF16BE($nu, false);
						$temppage = str_replace($alias_au, $nu, $temppage);
						if ($this->isunicode) {
							$temppage = str_replace($alias_bu, $nu, $temppage);
							$temppage = str_replace($alias_cu, $nu, $temppage);
							$temppage = str_replace($alias_b, $ns, $temppage);
							$temppage = str_replace($alias_c, $ns, $temppage);
						}
						$temppage = str_replace($alias_a, $ns, $temppage);
					}
					// save changes
					$this->setPageBuffer($p, $temppage);
				}
				// move pages
				$this->Bookmark($toc_name, 0, 0, $page_first);
				for ($i = 0; $i < $numpages; ++$i) {
					$this->movePage($page_last, $page);
				}
			}
		}

		/**
		 * Stores a copy of the current TCPDF object used for undo operation.
		 * @access public
		 * @since 4.5.029 (2009-03-19)
		 */
		public function startTransaction() {
			if (isset($this->objcopy)) {
				// remove previous copy
				$this->commitTransaction();
			}
			// record current page number and Y position
			$this->start_transaction_page = $this->page;
			$this->start_transaction_y = $this->y;
			// clone current object
			$this->objcopy = $this->objclone($this);
		}

		/**
		 * Delete the copy of the current TCPDF object used for undo operation.
		 * @access public
		 * @since 4.5.029 (2009-03-19)
		 */
		public function commitTransaction() {
			if (isset($this->objcopy)) {
				$this->objcopy->_destroy(true, true);
				unset($this->objcopy);
			}
		}

		/**
		 * This method allows to undo the latest transaction by returning the latest saved TCPDF object with startTransaction().
		 * @param boolean $self if true restores current class object to previous state without the need of reassignment via the returned value.
		 * @return TCPDF object.
		 * @access public
		 * @since 4.5.029 (2009-03-19)
		 */
		public function rollbackTransaction($self=false) {
			if (isset($this->objcopy)) {
				if (isset($this->objcopy->diskcache) AND $this->objcopy->diskcache) {
					// truncate files to previous values
					foreach ($this->objcopy->cache_file_length as $file => $length) {
						$file = substr($file, 1);
						$handle = fopen($file, 'r+');
						ftruncate($handle, $length);
					}
				}
				$this->_destroy(true, true);
				if ($self) {
					$objvars = get_object_vars($this->objcopy);
					foreach ($objvars as $key => $value) {
						$this->$key = $value;
					}
				}
				return $this->objcopy;
			}
			return $this;
		}

		/**
		 * Creates a copy of a class object
		 * @param object $object class object to be cloned
		 * @return cloned object
		 * @access public
		 * @since 4.5.029 (2009-03-19)
		 */
		public function objclone($object) {
			return @clone($object);
		}

		/**
		 * Determine whether a string is empty.
		 * @param string $str string to be checked
		 * @return boolean true if string is empty
		 * @access public
		 * @since 4.5.044 (2009-04-16)
		 */
		public function empty_string($str) {
			return (is_null($str) OR (is_string($str) AND (strlen($str) == 0)));
		}

		/**
		 * Find position of last occurrence of a substring in a string
		 * @param string $haystack The string to search in.
		 * @param string $needle substring to search.
		 * @param int $offset May be specified to begin searching an arbitrary number of characters into the string.
		 * @return Returns the position where the needle exists. Returns FALSE if the needle was not found.
		 * @access public
		 * @since 4.8.038 (2010-03-13)
		 */
		public function revstrpos($haystack, $needle, $offset = 0) {
			$length = strlen($haystack);
			$offset = ($offset > 0)?($length - $offset):abs($offset);
			$pos = strpos(strrev($haystack), strrev($needle), $offset);
			return ($pos === false)?false:($length - $pos - strlen($needle));
		}

		// --- MULTI COLUMNS METHODS -----------------------

		/**
		 * Set multiple columns of the same size
		 * @param int $numcols number of columns (set to zero to disable columns mode)
		 * @param int $width column width
		 * @param int $y column starting Y position (leave empty for current Y position)
		 * @access public
	 	 * @since 4.9.001 (2010-03-28)
		 */
		public function setEqualColumns($numcols=0, $width=0, $y='') {
			$this->columns = array();
			if ($numcols < 2) {
				$numcols = 0;
				$this->columns = array();
			} else {
				// maximum column width
				$maxwidth = ($this->w - $this->original_lMargin - $this->original_rMargin) / $numcols;
				if ($width > $maxwidth) {
					$width = $maxwidth;
				}
				if ($this->empty_string($y)) {
					$y = $this->y;
				}
				// space between columns
				$space = (($this->w - $this->original_lMargin - $this->original_rMargin - ($numcols * $width)) / ($numcols - 1));
				// fill the columns array (with, space, starting Y position)
				for ($i = 0; $i < $numcols; ++$i) {
					$this->columns[$i] = array('w' => $width, 's' => $space, 'y' => $y);
				}
			}
			$this->num_columns = $numcols;
			$this->current_column = 0;
			$this->column_start_page = $this->page;
		}

		/**
		 * Set columns array.
		 * Each column is represented by and array with the following keys: (w = width, s = space between columns, y = column top position).
		 * @param array $columns
		 * @access public
	 	 * @since 4.9.001 (2010-03-28)
		 */
		public function setColumnsArray($columns) {
			$this->columns = $columns;
			$this->num_columns = count($columns);
			$this->current_column = 0;
			$this->column_start_page = $this->page;
		}

		/**
		 * Set position at a given column
		 * @param int $col column number (from 0 to getNumberOfColumns()-1); empty string = current column.
		 * @access public
	 	 * @since 4.9.001 (2010-03-28)
		 */
		public function selectColumn($col='') {
			if (is_string($col)) {
				$col = $this->current_column;
			} elseif($col >= $this->num_columns) {
				$col = 0;
			}
			if ($this->num_columns > 1) {
				if ($col != $this->current_column) {
					// move pointer at column top on the first page
					if ($this->column_start_page == $this->page) {
						$this->y = $this->columns[$col]['y'];
					} else {
						$this->y = $this->tMargin;
					}
				}
				// set X position of the current column by case
				$listindent = ($this->listindentlevel * $this->listindent);
				if ($this->rtl) {
					$x = $this->w - $this->original_rMargin - ($col * ($this->columns[$col]['w'] + $this->columns[$col]['s']));
					$this->SetRightMargin($this->w - $x + $listindent);
					$this->SetLeftMargin($x - $this->columns[$col]['w']);
					$this->x = $x - $listindent;
				} else {
					$x = $this->original_lMargin + ($col * ($this->columns[$col]['w'] + $this->columns[$col]['s']));
					$this->SetLeftMargin($x + $listindent);
					$this->SetRightMargin($this->w - $x - $this->columns[$col]['w']);
					$this->x = $x + $listindent;
				}
				$this->columns[$col]['x'] = $x;
			} else {
				// restore original margins
				$this->lMargin = $this->original_lMargin;
				$this->rMargin = $this->original_rMargin;
			}
			$this->current_column = $col;
			// fix for HTML mode
			$this->newline = true;
			// print HTML table header (if any)
			if (!$this->empty_string($this->thead) AND (!$this->inthead)) {
				// print table header
				$this->writeHTML($this->thead, false, false, false, false, '');
			}
		}

		/**
		 * Serialize an array of parameters to be used with TCPDF tag in HTML code.
		 * @param array $pararray parameters array
		 * @return sting containing serialized data
		 * @access public
	 	 * @since 4.9.006 (2010-04-02)
		 */
		public function serializeTCPDFtagParameters($pararray) {
			return urlencode(serialize($pararray));
		}

		/**
		 * Set Text rendering mode.
		 * @param int $stroke outline size in user units (0 = disable).
		 * @param boolean $fill if true fills the text (default).
		 * @param boolean $clip if true activate clipping mode
		 * @access public
		 * @since 4.9.008 (2009-04-02)
		 */
		public function setTextRenderingMode($stroke=0, $fill=true, $clip=false) {
			// Ref.: PDF 32000-1:2008 - 9.3.6 Text Rendering Mode
			// convert text rendering parameters
			if ($stroke < 0) {
				$stroke = 0;
			}
			if ($fill === true) {
				if ($stroke > 0) {
					if ($clip === true) {
						// Fill, then stroke text and add to path for clipping
						$textrendermode = 6;
					} else {
						// Fill, then stroke text
						$textrendermode = 2;
					}
					$textstrokewidth = $stroke;
				} else {
					if ($clip === true) {
						// Fill text and add to path for clipping
						$textrendermode = 4;
					} else {
						// Fill text
						$textrendermode = 0;
					}
				}
			} else {
				if ($stroke > 0) {
					if ($clip === true) {
						// Stroke text and add to path for clipping
						$textrendermode = 5;
					} else {
						// Stroke text
						$textrendermode = 1;
					}
					$textstrokewidth = $stroke;
				} else {
					if ($clip === true) {
						// Add text to path for clipping
						$textrendermode = 7;
					} else {
						// Neither fill nor stroke text (invisible)
						$textrendermode = 3;
					}
				}
			}
			$this->textrendermode = $textrendermode;
			$this->textstrokewidth = $stroke * $this->k;
		}

		/**
		 * Returns an array of chars containing soft hyphens.
		 * @param array $word array of chars
		 * @param array $patterns Array of hypenation patterns.
		 * @param array $dictionary Array of words to be returned without applying the hyphenation algoritm.
		 * @param int $leftmin Minimum number of character to leave on the left of the word without applying the hyphens.
		 * @param int $rightmin Minimum number of character to leave on the right of the word without applying the hyphens.
		 * @param int $charmin Minimum word lenght to apply the hyphenation algoritm.
		 * @param int $charmax Maximum lenght of broken piece of word.
		 * @return array text with soft hyphens
		 * @author Nicola Asuni
		 * @since 4.9.012 (2010-04-12)
		 * @access protected
		 */
		protected function hyphenateWord($word, $patterns, $dictionary=array(), $leftmin=1, $rightmin=2, $charmin=1, $charmax=8) {
			$hyphenword = array(); // hyphens positions
			$numchars = count($word);
			if ($numchars <= $charmin) {
				return $word;
			}
			$word_string = $this->UTF8ArrSubString($word);
			// some words will be returned as-is
			$pattern = '/^([a-zA-Z0-9_\.\-]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$/';
			if (preg_match($pattern, $word_string) > 0) {
				// email
				return $word;
			}
			$pattern = '/(([a-zA-Z0-9\-]+\.)?)((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$/';
			if (preg_match($pattern, $word_string) > 0) {
				// URL
				return $word;
			}
			if (isset($dictionary[$word_string])) {
				return $this->UTF8StringToArray($dictionary[$word_string]);
			}
			// suround word with '_' characters
			$tmpword = array_merge(array(95), $word, array(95));
			$tmpnumchars = $numchars + 2;
			$maxpos = $tmpnumchars - $charmin;
			for ($pos = 0; $pos < $maxpos; ++$pos) {
				$imax = min(($tmpnumchars - $pos), $charmax);
				for ($i = $charmin; $i <= $imax; ++$i) {
					$subword = strtolower($this->UTF8ArrSubString($tmpword, $pos, $pos + $i));
					if (isset($patterns[$subword])) {
						$pattern = $this->UTF8StringToArray($patterns[$subword]);
						$pattern_length = count($pattern);
						$digits = 1;
						for ($j = 0; $j < $pattern_length; ++$j) {
							// check if $pattern[$j] is a number
							if (($pattern[$j] >= 48) AND ($pattern[$j] <= 57)) {
								if ($j == 0) {
									$zero = $pos - 1;
								} else {
									$zero = $pos + $j - $digits;
								}
								if (!isset($hyphenword[$zero]) OR ($hyphenword[$zero] != $pattern[$j])) {
									$hyphenword[$zero] = $this->unichr($pattern[$j]);
								}
								++$digits;
							}
						}
					}
				}
			}
			$inserted = 0;
			$maxpos = $numchars - $rightmin;
			for($i = $leftmin; $i <= $maxpos; ++$i) {
				if(isset($hyphenword[$i]) AND (($hyphenword[$i] % 2) != 0)) {
					// 173 = soft hyphen character
					array_splice($word, $i + $inserted, 0, 173);
					++$inserted;
				}
			}
			return $word;
		}

		/**
		 * Returns an array of hyphenation patterns.
		 * @param string $file TEX file containing hypenation patterns. TEX pattrns can be downloaded from http://www.ctan.org/tex-archive/language/hyph-utf8/tex/generic/hyph-utf8/patterns/
		 * @return array of hyphenation patterns
		 * @author Nicola Asuni
		 * @since 4.9.012 (2010-04-12)
		 * @access public
		 */
		public function getHyphenPatternsFromTEX($file) {
			// TEX patterns are available at:
			// http://www.ctan.org/tex-archive/language/hyph-utf8/tex/generic/hyph-utf8/patterns/
			$data = file_get_contents($file);
			$patterns = array();
			// remove comments
			$data = preg_replace('/\%[^\n]*/', '', $data);
			// extract the patterns part
			preg_match('/\\\\patterns\{([^\}]*)\}/i', $data, $matches);
			$data = trim(substr($matches[0], 10, -1));
			// extract each pattern
			$patterns_array = preg_split('/[\s]+/', $data);
			// create new language array of patterns
			$patterns = array();
			foreach($patterns_array as $val) {
				if (!$this->empty_string($val)) {
					$val = trim($val);
					$val = str_replace('\'', '\\\'', $val);
					$key = preg_replace('/[0-9]+/', '', $val);
					$patterns[$key] = $val;
				}
			}
			return $patterns;
		}

		/**
		 * Returns text with soft hyphens.
		 * @param string $text text to process
		 * @param mixed $patterns Array of hypenation patterns or a TEX file containing hypenation patterns. TEX patterns can be downloaded from http://www.ctan.org/tex-archive/language/hyph-utf8/tex/generic/hyph-utf8/patterns/
		 * @param array $dictionary Array of words to be returned without applying the hyphenation algoritm.
		 * @param int $leftmin Minimum number of character to leave on the left of the word without applying the hyphens.
		 * @param int $rightmin Minimum number of character to leave on the right of the word without applying the hyphens.
		 * @param int $charmin Minimum word lenght to apply the hyphenation algoritm.
		 * @param int $charmax Maximum lenght of broken piece of word.
		 * @return array text with soft hyphens
		 * @author Nicola Asuni
		 * @since 4.9.012 (2010-04-12)
		 * @access public
		 */
		public function hyphenateText($text, $patterns, $dictionary=array(), $leftmin=1, $rightmin=2, $charmin=1, $charmax=8) {
			global $unicode;
			$text = $this->unhtmlentities($text);
			$word = array(); // last word
			$txtarr = array(); // text to be returned
			$intag = false; // true if we are inside an HTML tag
			if (!is_array($patterns)) {
				$patterns = $this->getHyphenPatternsFromTEX($patterns);
			}
			// get array of characters
			$unichars = $this->UTF8StringToArray($text);
			// for each char
			foreach ($unichars as $char) {
				if ((!$intag) AND $unicode[$char] == 'L') {
					// letter character
					$word[] = $char;
				} else {
					// other type of character
					if (!$this->empty_string($word)) {
						// hypenate the word
						$txtarr = array_merge($txtarr, $this->hyphenateWord($word, $patterns, $dictionary, $leftmin, $rightmin, $charmin, $charmax));
						$word = array();
					}
					$txtarr[] = $char;
					if (chr($char) == '<') {
						// we are inside an HTML tag
						$intag = true;
					} elseif ($intag AND (chr($char) == '>')) {
						// end of HTML tag
						$intag = false;
					}
				}
			}
			if (!$this->empty_string($word)) {
				// hypenate the word
				$txtarr = array_merge($txtarr, $this->hyphenateWord($word, $patterns, $dictionary, $leftmin, $rightmin, $charmin, $charmax));
			}
			// convert char array to string and return
			return $this->UTF8ArrSubString($txtarr);
		}

		/**
		 * Enable/disable rasterization of SVG images using ImageMagick library.
		 * @param boolean $mode if true enable rasterization, false otherwise.
		 * @access public
		 * @since 5.0.000 (2010-04-27)
		 */
		public function setRasterizeVectorImages($mode) {
			$this->rasterize_vector_images = $mode;
		}

		/**
		 * Get the Path-Painting Operators.
		 * @param string $style Style of rendering. Possible values are:
		 * 

		 *   
S or D: Stroke the path.
		 *   
s or d: Close and stroke the path.
		 *   
f or F: Fill the path, using the nonzero winding number rule to determine the region to fill.
		 *   
f* or F*: Fill the path, using the even-odd rule to determine the region to fill.
		 *   
B or FD or DF: Fill and then stroke the path, using the nonzero winding number rule to determine the region to fill.
		 *   
B* or F*D or DF*: Fill and then stroke the path, using the even-odd rule to determine the region to fill.
		 *   
b or fd or df: Close, fill, and then stroke the path, using the nonzero winding number rule to determine the region to fill.
		 *   
b or f*d or df*: Close, fill, and then stroke the path, using the even-odd rule to determine the region to fill.
		 *   
CNZ: Clipping mode using the even-odd rule to determine which regions lie inside the clipping path.
		 *   
CEO: Clipping mode using the nonzero winding number rule to determine which regions lie inside the clipping path
		 *   
n: End the path object without filling or stroking it.
		 * 
		 * @param string $default default style
		 * @param boolean $mode if true enable rasterization, false otherwise.
		 * @author Nicola Asuni
		 * @access protected
		 * @since 5.0.000 (2010-04-30)
		 */
		protected function getPathPaintOperator($style, $default='S') {
			$op = '';
			switch($style) {
				case 'S':
				case 'D': {
					$op = 'S';
					break;
				}
				case 's':
				case 'd': {
					$op = 's';
					break;
				}
				case 'f':
				case 'F': {
					$op = 'f';
					break;
				}
				case 'f*':
				case 'F*': {
					$op = 'f*';
					break;
				}
				case 'B':
				case 'FD':
				case 'DF': {
					$op = 'B';
					break;
				}
				case 'B*':
				case 'F*D':
				case 'DF*': {
					$op = 'B*';
					break;
				}
				case 'b':
				case 'fd':
				case 'df': {
					$op = 'b';
					break;
				}
				case 'b*':
				case 'f*d':
				case 'df*': {
					$op = 'b*';
					break;
				}
				case 'CNZ': {
					$op = 'W n';
					break;
				}
				case 'CEO': {
					$op = 'W* n';
					break;
				}
				case 'n': {
					$op = 'n';
					break;
				}
				default: {
					if (!empty($default)) {
						$op = $this->getPathPaintOperator($default, '');
					} else {
						$op = '';
					}
				}
			}
			return $op;
		}

		// -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
		// SVG METHODS
		// -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-

		/**
		 * Embedd a Scalable Vector Graphics (SVG) image.
		 * NOTE: SVG standard is not yet fully implemented, use the setRasterizeVectorImages() method to enable/disable rasterization of SVG images using ImageMagick library.
		 * @param string $file Name of the SVG file.
		 * @param float $x Abscissa of the upper-left corner.
		 * @param float $y Ordinate of the upper-left corner.
		 * @param float $w Width of the image in the page. If not specified or equal to zero, it is automatically calculated.
		 * @param float $h Height of the image in the page. If not specified or equal to zero, it is automatically calculated.
		 * @param mixed $link URL or identifier returned by AddLink().
		 * @param string $align Indicates the alignment of the pointer next to image insertion relative to image height. The value can be:
T: top-right for LTR or top-left for RTL
M: middle-right for LTR or middle-left for RTL
B: bottom-right for LTR or bottom-left for RTL
N: next line
		 * @param string $palign Allows to center or align the image on the current line. Possible values are:
L : left align
C : center
R : right align
'' : empty string : left for LTR or right for RTL
		 * @param mixed $border Indicates if borders must be drawn around the image. The value can be either a number:
0: no border (default)
1: frame
or a string containing some or all of the following characters (in any order):
L: left
T: top
R: right
B: bottom
		 * @param boolean $fitonpage if true the image is resized to not exceed page dimensions.
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access public
		 */
		public function ImageSVG($file, $x='', $y='', $w=0, $h=0, $link='', $align='', $palign='', $border=0, $fitonpage=false) {
			if ($this->rasterize_vector_images) {
				// convert SVG to raster image using GD or ImageMagick libraries
				return $this->Image($file, $x, $y, $w, $h, 'SVG', $link, $align, true, 300, $palign, false, false, $border, false, false, false);
			}
			$this->svgdir = dirname($file);
			$svgdata = file_get_contents($file);
			if ($svgdata === false) {
				$this->Error('SVG file not found: '.$file);
			}
			if ($x === '') {
				$x = $this->x;
			}
			if ($y === '') {
				$y = $this->y;
			}
			$k = $this->k;
			$ox = 0;
			$oy = 0;
			$ow = $w;
			$oh = $h;
			$aspect_ratio_align = 'xMidYMid';
			$aspect_ratio_ms = 'meet';
			$regs = array();
			// get original image width and height
			preg_match('/]*)>/si', $svgdata, $regs);
			if (isset($regs[1]) AND !empty($regs[1])) {
				$tmp = array();
				if (preg_match('/[\s]+x[\s]*=[\s]*"([^"]*)"/si', $regs[1], $tmp)) {
					$ox = $this->getHTMLUnitToUnits($tmp[1], 0, $this->svgunit, false);
				}
				$tmp = array();
				if (preg_match('/[\s]+y[\s]*=[\s]*"([^"]*)"/si', $regs[1], $tmp)) {
					$oy = $this->getHTMLUnitToUnits($tmp[1], 0, $this->svgunit, false);
				}
				$tmp = array();
				if (preg_match('/[\s]+width[\s]*=[\s]*"([^"]*)"/si', $regs[1], $tmp)) {
					$ow = $this->getHTMLUnitToUnits($tmp[1], 1, $this->svgunit, false);
				}
				$tmp = array();
				if (preg_match('/[\s]+height[\s]*=[\s]*"([^"]*)"/si', $regs[1], $tmp)) {
					$oh = $this->getHTMLUnitToUnits($tmp[1], 1, $this->svgunit, false);
				}
				$tmp = array();
				$view_box = array();
				if (preg_match('/[\s]+viewBox[\s]*=[\s]*"[\s]*([0-9\.\-]+)[\s]+([0-9\.\-]+)[\s]+([0-9\.]+)[\s]+([0-9\.]+)[\s]*"/si', $regs[1], $tmp)) {
					if (count($tmp) == 5) {
						array_shift($tmp);
						foreach ($tmp as $key => $val) {
							$view_box[$key] = $this->getHTMLUnitToUnits($val, 0, $this->svgunit, false);
						}
						$ox = $view_box[0];
						$oy = $view_box[1];
					}
					// get aspect ratio
					$tmp = array();
					if (preg_match('/[\s]+preserveAspectRatio[\s]*=[\s]*"([^"]*)"/si', $regs[1], $tmp)) {
						$aspect_ratio = preg_split("/[\s]+/si", $tmp[1]);
						switch (count($aspect_ratio)) {
							case 3: {
								$aspect_ratio_align = $aspect_ratio[1];
								$aspect_ratio_ms = $aspect_ratio[2];
								break;
							}
							case 2: {
								$aspect_ratio_align = $aspect_ratio[0];
								$aspect_ratio_ms = $aspect_ratio[1];
								break;
							}
							case 1: {
								$aspect_ratio_align = $aspect_ratio[0];
								$aspect_ratio_ms = 'meet';
								break;
							}
						}
					}
				}
			}
			// calculate image width and height on document
			if (($w <= 0) AND ($h <= 0)) {
				// convert image size to document unit
				$w = $ow;
				$h = $oh;
			} elseif ($w <= 0) {
				$w = $h * $ow / $oh;
			} elseif ($h <= 0) {
				$h = $w * $oh / $ow;
			}
			// Check whether we need a new page first as this does not fit
			$prev_x = $this->x;
			if ($this->checkPageBreak($h, $y)) {
				$y = $this->y;
				if ($this->rtl) {
					$x += ($prev_x - $this->x);
				} else {
					$x += ($this->x - $prev_x);
				}
			}
			// resize image to be contained on a single page
			if ($fitonpage) {
				$ratio_wh = $w / $h;
				if (($y + $h) > $this->PageBreakTrigger) {
					$h = $this->PageBreakTrigger - $y;
					$w = $h * $ratio_wh;
				}
				if ((!$this->rtl) AND (($x + $w) > ($this->w - $this->rMargin))) {
					$w = $this->w - $this->rMargin - $x;
					$h = $w / $ratio_wh;
				} elseif (($this->rtl) AND (($x - $w) < ($this->lMargin))) {
					$w = $x - $this->lMargin;
					$h = $w / $ratio_wh;
				}
			}
			// set alignment
			$this->img_rb_y = $y + $h;
			// set alignment
			if ($this->rtl) {
				if ($palign == 'L') {
					$ximg = $this->lMargin;
				} elseif ($palign == 'C') {
					$ximg = ($this->w + $this->lMargin - $this->rMargin - $w) / 2;
				} elseif ($palign == 'R') {
					$ximg = $this->w - $this->rMargin - $w;
				} else {
					$ximg = $x - $w;
				}
				$this->img_rb_x = $ximg;
			} else {
				if ($palign == 'L') {
					$ximg = $this->lMargin;
				} elseif ($palign == 'C') {
					$ximg = ($this->w + $this->lMargin - $this->rMargin - $w) / 2;
				} elseif ($palign == 'R') {
					$ximg = $this->w - $this->rMargin - $w;
				} else {
					$ximg = $x;
				}
				$this->img_rb_x = $ximg + $w;
			}
			// store current graphic vars
			$gvars = $this->getGraphicVars();
			// store SVG position and scale factors
			$svgoffset_x = ($ximg - $ox) * $this->k;
			$svgoffset_y = -($y - $oy) * $this->k;
			if (isset($view_box[2]) AND ($view_box[2] > 0) AND ($view_box[3] > 0)) {
				$ow = $view_box[2];
				$oh = $view_box[3];
			}
			$svgscale_x = $w / $ow;
			$svgscale_y = $h / $oh;
			// scaling and alignment
			if ($aspect_ratio_align != 'none') {
				// store current scaling values
				$svgscale_old_x = $svgscale_x;
				$svgscale_old_y = $svgscale_y;
				// force uniform scaling
				if ($aspect_ratio_ms == 'slice') {
					// the entire viewport is covered by the viewBox
					if ($svgscale_x > $svgscale_y) {
						$svgscale_y = $svgscale_x;
					} elseif ($svgscale_x < $svgscale_y) {
						$svgscale_x = $svgscale_y;
					}
				} else { // meet
					// the entire viewBox is visible within the viewport
					if ($svgscale_x < $svgscale_y) {
						$svgscale_y = $svgscale_x;
					} elseif ($svgscale_x > $svgscale_y) {
						$svgscale_x = $svgscale_y;
					}
				}
				// correct X alignment
				switch (substr($aspect_ratio_align, 1, 3)) {
					case 'Min': {
						// do nothing
						break;
					}
					case 'Max': {
						$svgoffset_x += (($w * $this->k) - ($ow * $this->k * $svgscale_x));
						break;
					}
					default:
					case 'Mid': {
						$svgoffset_x += ((($w * $this->k) - ($ow * $this->k * $svgscale_x)) / 2);
						break;
					}
				}
				// correct Y alignment
				switch (substr($aspect_ratio_align, 5)) {
					case 'Min': {
						// do nothing
						break;
					}
					case 'Max': {
						$svgoffset_y -= (($h * $this->k) - ($oh * $this->k * $svgscale_y));
						break;
					}
					default:
					case 'Mid': {
						$svgoffset_y -= ((($h * $this->k) - ($oh * $this->k * $svgscale_y)) / 2);
						break;
					}
				}
			}
			// save the current graphic state
			$this->_out('q'.$this->epsmarker);
			// set initial clipping mask
			$this->Rect($x, $y, $w, $h, 'CNZ', array(), array());
			// scale and translate
			$e = $ox * $this->k * (1 - $svgscale_x);
			$f = ($this->h - $oy) * $this->k * (1 - $svgscale_y);
			$this->_out(sprintf('%.3F %.3F %.3F %.3F %.3F %.3F cm', $svgscale_x, 0, 0, $svgscale_y, $e + $svgoffset_x, $f + $svgoffset_y));
			// creates a new XML parser to be used by the other XML functions
			$this->parser = xml_parser_create('UTF-8');
			// the following function allows to use parser inside object
			xml_set_object($this->parser, $this);
			// disable case-folding for this XML parser
			xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
			// sets the element handler functions for the XML parser
			xml_set_element_handler($this->parser, 'startSVGElementHandler', 'endSVGElementHandler');
			// sets the character data handler function for the XML parser
			xml_set_character_data_handler($this->parser, 'segSVGContentHandler');
			// start parsing an XML document
			if(!xml_parse($this->parser, $svgdata)) {
				$error_message = sprintf("SVG Error: %s at line %d", xml_error_string(xml_get_error_code($this->parser)), xml_get_current_line_number($this->parser));
				$this->Error($error_message);
			}
			// free this XML parser
			xml_parser_free($this->parser);
			// restore previous graphic state
			$this->_out($this->epsmarker.'Q');
			// restore  graphic vars
			$this->setGraphicVars($gvars);
			if (!empty($border)) {
				$bx = $x;
				$by = $y;
				$this->x = $ximg;
				if ($this->rtl) {
					$this->x += $w;
				}
				$this->y = $y;
				$this->Cell($w, $h, '', $border, 0, '', 0, '', 0);
				$this->x = $bx;
				$this->y = $by;
			}
			if ($link) {
				$this->Link($ximg, $y, $w, $h, $link, 0);
			}
			// set pointer to align the successive text/objects
			switch($align) {
				case 'T':{
					$this->y = $y;
					$this->x = $this->img_rb_x;
					break;
				}
				case 'M':{
					$this->y = $y + round($h/2);
					$this->x = $this->img_rb_x;
					break;
				}
				case 'B':{
					$this->y = $this->img_rb_y;
					$this->x = $this->img_rb_x;
					break;
				}
				case 'N':{
					$this->SetY($this->img_rb_y);
					break;
				}
				default:{
					break;
				}
			}
			$this->endlinex = $this->img_rb_x;
		}

		/**
		 * Get the tranformation matrix from SVG transform attribute
		 * @param string transformation
		 * @return array of transformations
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function getSVGTransformMatrix($attribute) {
			// identity matrix
			$tm = array(1, 0, 0, 1, 0, 0);
			$continue = true;
			while ($continue) {
				$continue = false;
				// matrix
				$regs = array();
				if (preg_match('/matrix\(([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], '', $attribute);
					$continue = true;
					$a = $regs[1];
					$b = $regs[2];
					$c = $regs[3];
					$d = $regs[4];
					$e = $regs[5];
					$f = $regs[6];
					$tm = $this->getTransformationMatrixProduct($tm, array($a, $b, $c, $d, $e, $f));
				}
				// translate x
				$regs = array();
				if (preg_match('/translate\(([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], 'translate('.$regs[1].',0)', $attribute);
					$continue = true;
				}
				// translate x,y
				$regs = array();
				if (preg_match('/translate\(([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], '', $attribute);
					$continue = true;
					$e = $regs[1];
					$f = $regs[2];
					$tm = $this->getTransformationMatrixProduct($tm, array(1, 0, 0, 1, $e, $f));
				}
				// scale x
				$regs = array();
				if (preg_match('/scale\(([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], 'scale('.$regs[1].','.$regs[1].')', $attribute);
					$continue = true;
				}
				// scale x,y
				$regs = array();
				if (preg_match('/scale\(([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], '', $attribute);
					$continue = true;
					$a = $regs[1];
					if (isset($regs[2]) AND (strlen(trim($regs[2])) > 0)) {
						$d = $regs[2];
					} else {
						$d = $a;
					}
					$tm = $this->getTransformationMatrixProduct($tm, array($a, 0, 0, $d, 0, 0));
				}
				// rotate ang
				$regs = array();
				if (preg_match('/rotate\(([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], 'rotate('.$regs[1].',0,0)', $attribute);
					$continue = true;
				}
				// rotate ang,x,y
				$regs = array();
				if (preg_match('/rotate\(([0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)[\,\s]+([a-z0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], '', $attribute);
					$continue = true;
					$ang = deg2rad($regs[1]);
					$a = cos($ang);
					$b = sin($ang);
					$c = -$b;
					$d = $a;
					$x = $regs[2];
					$y = $regs[3];
					$e = ($x * (1 - $a)) - ($y * $c);
					$f = ($y * (1 - $d)) - ($x * $b);
					$tm = $this->getTransformationMatrixProduct($tm, array($a, $b, $c, $d, $e, $f));
				}
				// skewX
				$regs = array();
				if (preg_match('/skewX\(([0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], '', $attribute);
					$continue = true;
					$c = tan(deg2rad($regs[1]));
					$tm = $this->getTransformationMatrixProduct($tm, array(1, 0, $c, 1, 0, 0));
				}
				// skewY
				$regs = array();
				if (preg_match('/skewY\(([0-9\-\.]+)\)/si', $attribute, $regs)) {
					$attribute = str_replace($regs[0], '', $attribute);
					$continue = true;
					$b = tan(deg2rad($regs[1]));
					$tm = $this->getTransformationMatrixProduct($tm, array(1, $b, 0, 1, 0, 0));
				}
			}
			return $tm;
		}

		/**
		 * Get the product of two SVG tranformation matrices
		 * @param array $ta first SVG tranformation matrix
		 * @param array $tb second SVG tranformation matrix
		 * @return transformation array
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function getTransformationMatrixProduct($ta, $tb)  {
			$tm = array();
			$tm[0] = ($ta[0] * $tb[0]) + ($ta[2] * $tb[1]);
			$tm[1] = ($ta[1] * $tb[0]) + ($ta[3] * $tb[1]);
			$tm[2] = ($ta[0] * $tb[2]) + ($ta[2] * $tb[3]);
			$tm[3] = ($ta[1] * $tb[2]) + ($ta[3] * $tb[3]);
			$tm[4] = ($ta[0] * $tb[4]) + ($ta[2] * $tb[5]) + $ta[4];
			$tm[5] = ($ta[1] * $tb[4]) + ($ta[3] * $tb[5]) + $ta[5];
			return $tm;
		}

		/**
		 * Convert SVG transformation matrix to PDF.
		 * @param array $tm original SVG transformation matrix
		 * @return array transformation matrix
		 * @access protected
		 * @since 5.0.000 (2010-05-02)
		 */
		protected function convertSVGtMatrix($tm) {
			$a = $tm[0];
			$b = -$tm[1];
			$c = -$tm[2];
			$d = $tm[3];
			$e = $this->getHTMLUnitToUnits($tm[4], 1, $this->svgunit, false) * $this->k;
			$f = -$this->getHTMLUnitToUnits($tm[5], 1, $this->svgunit, false) * $this->k;
			$x = 0;
			$y = $this->h * $this->k;
			$e = ($x * (1 - $a)) - ($y * $c) + $e;
			$f = ($y * (1 - $d)) - ($x * $b) + $f;
			return array($a, $b, $c, $d, $e, $f);
		}

		/**
		 * Apply SVG graphic transformation matrix.
		 * @param array $tm original SVG transformation matrix
		 * @access protected
		 * @since 5.0.000 (2010-05-02)
		 */
		protected function SVGTransform($tm) {
			$this->Transform($this->convertSVGtMatrix($tm));
		}

		/**
		 * Apply the requested SVG styles (*** TO BE COMPLETED ***)
		 * @param array $svgstyle array of SVG styles to apply
		 * @param array $prevsvgstyle array of previous SVG style
		 * @param int $x X origin of the bounding box
		 * @param int $y Y origin of the bounding box
		 * @param int $w width of the bounding box
		 * @param int $h height of the bounding box
		 * @param string $clip_function clip function
		 * @param array $clip_params array of parameters for clipping function
		 * @return object style
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function setSVGStyles($svgstyle, $prevsvgstyle, $x=0, $y=0, $w=1, $h=1, $clip_function='', $clip_params=array())  {
			$objstyle = '';
			if(!isset($svgstyle['opacity'])) {
				return $objstyle;
			}
			// clip-path
			$regs = array();
			if (preg_match('/url\([\s]*\#([^\)]*)\)/si', $svgstyle['clip-path'], $regs)) {
				$clip_path = $this->svgclippaths[$regs[1]];
				foreach ($clip_path as $cp) {
					$this->startSVGElementHandler('clip-path', $cp['name'], $cp['attribs']);
				}
			}
			//$this->SetAlpha(1); // reset alpha
			// opacity
			if ($svgstyle['opacity'] != 1) {
				$this->SetAlpha($svgstyle['opacity']);
			}
			// color
			$fill_color = $this->convertHTMLColorToDec($svgstyle['color']);
			$this->SetFillColorArray($fill_color);
			// text color
			$text_color = $this->convertHTMLColorToDec($svgstyle['text-color']);
			$this->SetTextColorArray($text_color);
			// clip
			if (preg_match('/rect\(([a-z0-9\-\.]*)[\s]*([a-z0-9\-\.]*)[\s]*([a-z0-9\-\.]*)[\s]*([a-z0-9\-\.]*)\)/si', $svgstyle['clip'], $regs)) {
				$top = (isset($regs[1])?$this->getHTMLUnitToUnits($regs[1], 0, $this->svgunit, false):0);
				$right = (isset($regs[2])?$this->getHTMLUnitToUnits($regs[2], 0, $this->svgunit, false):0);
				$bottom = (isset($regs[3])?$this->getHTMLUnitToUnits($regs[3], 0, $this->svgunit, false):0);
				$left = (isset($regs[4])?$this->getHTMLUnitToUnits($regs[4], 0, $this->svgunit, false):0);
				$cx = $x + $left;
				$cy = $y + $top;
				$cw = $w - $left - $right;
				$ch = $h - $top - $bottom;
				if ($svgstyle['clip-rule'] == 'evenodd') {
					$clip_rule = 'CNZ';
				} else {
					$clip_rule = 'CEO';
				}
				$this->Rect($cx, $cy, $cw, $ch, $clip_rule, array(), array());
			}
			// fill
			$regs = array();
			if (preg_match('/url\([\s]*\#([^\)]*)\)/si', $svgstyle['fill'], $regs)) {
				// gradient
				$gradient = $this->svggradients[$regs[1]];
				if (isset($gradient['xref'])) {
					// reference to another gradient definition
					$newgradient = $this->svggradients[$gradient['xref']];
					$newgradient['coords'] = $gradient['coords'];
					$newgradient['mode'] = $gradient['mode'];
					$newgradient['gradientUnits'] = $gradient['gradientUnits'];
					if (isset($gradient['gradientTransform'])) {
						$newgradient['gradientTransform'] = $gradient['gradientTransform'];
					}
					$gradient = $newgradient;
				}
				//save current Graphic State
				$this->_out('q');
				//set clipping area
				if (!empty($clip_function) AND method_exists($this, $clip_function)) {
					$bbox = call_user_func_array(array($this, $clip_function), $clip_params);
					if (is_array($bbox) AND (count($bbox) == 4)) {
						list($x, $y, $w, $h) = $bbox;
					}
				}
				if ($gradient['mode'] == 'measure') {
					if (isset($gradient['gradientTransform']) AND !empty($gradient['gradientTransform'])) {
						$gtm = $gradient['gradientTransform'];
						// apply transformation matrix
						$xa = ($gtm[0] * $gradient['coords'][0]) + ($gtm[2] * $gradient['coords'][1]) + $gtm[4];
						$ya = ($gtm[1] * $gradient['coords'][0]) + ($gtm[3] * $gradient['coords'][1]) + $gtm[5];
						$xb = ($gtm[0] * $gradient['coords'][2]) + ($gtm[2] * $gradient['coords'][3]) + $gtm[4];
						$yb = ($gtm[1] * $gradient['coords'][2]) + ($gtm[3] * $gradient['coords'][3]) + $gtm[5];
						if (isset($gradient['coords'][4])) {
							$gradient['coords'][4] = sqrt(pow(($gtm[0] * $gradient['coords'][4]), 2) + pow(($gtm[1] * $gradient['coords'][4]), 2));
						}
						$gradient['coords'][0] = $xa;
						$gradient['coords'][1] = $ya;
						$gradient['coords'][2] = $xb;
						$gradient['coords'][3] = $yb;

					}
					// convert SVG coordinates to user units
					$gradient['coords'][0] = $this->getHTMLUnitToUnits($gradient['coords'][0], 0, $this->svgunit, false);
					$gradient['coords'][1] = $this->getHTMLUnitToUnits($gradient['coords'][1], 0, $this->svgunit, false);
					$gradient['coords'][2] = $this->getHTMLUnitToUnits($gradient['coords'][2], 0, $this->svgunit, false);
					$gradient['coords'][3] = $this->getHTMLUnitToUnits($gradient['coords'][3], 0, $this->svgunit, false);
					if (isset($gradient['coords'][4])) {
						$gradient['coords'][4] = $this->getHTMLUnitToUnits($gradient['coords'][4], 0, $this->svgunit, false);
					}
					// shift units
					if ($gradient['gradientUnits'] == 'objectBoundingBox') {
						// convert to SVG coordinate system
						$gradient['coords'][0] += $x;
						$gradient['coords'][1] += $y;
						$gradient['coords'][2] += $x;
						$gradient['coords'][3] += $y;
					}
					// calculate percentages
					$gradient['coords'][0] = ($gradient['coords'][0] - $x) / $w;
					$gradient['coords'][1] = ($gradient['coords'][1] - $y) / $h;
					$gradient['coords'][2] = ($gradient['coords'][2] - $x) / $w;
					$gradient['coords'][3] = ($gradient['coords'][3] - $y) / $h;
					if (isset($gradient['coords'][4])) {
						$gradient['coords'][4] /= $w;
					}
					// fix values
					foreach($gradient['coords'] as $key => $val) {
						if ($val < 0) {
							$gradient['coords'][$key] = 0;
						} elseif ($val > 1) {
							$gradient['coords'][$key] = 1;
						}
					}
					if (($gradient['type'] == 2) AND ($gradient['coords'][0] == $gradient['coords'][2]) AND ($gradient['coords'][1] == $gradient['coords'][3])) {
						// single color (no shading)
						$gradient['coords'][0] = 1;
						$gradient['coords'][1] = 0;
						$gradient['coords'][2] = 0.999;
						$gradient['coords'][3] = 0;
					}
				}
				// swap Y coordinates
				$tmp = $gradient['coords'][1];
				$gradient['coords'][1] = $gradient['coords'][3];
				$gradient['coords'][3] = $tmp;
				// set transformation map for gradient
				if (($gradient['type'] == 3) AND ($gradient['mode'] == 'measure')) {
					// gradient is always circular
					$cy = $this->h - $y - ($gradient['coords'][1] * ($w + $h));
					$this->_out(sprintf('%.3F 0 0 %.3F %.3F %.3F cm', $w*$this->k, $w*$this->k, $x*$this->k, $cy*$this->k));
				} else {
					$this->_out(sprintf('%.3F 0 0 %.3F %.3F %.3F cm', $w*$this->k, $h*$this->k, $x*$this->k, ($this->h-($y+$h))*$this->k));
				}
				if (count($gradient['stops']) > 1) {
					$this->Gradient($gradient['type'], $gradient['coords'], $gradient['stops'], array(), false);
				}
			} elseif ($svgstyle['fill'] != 'none') {
				$fill_color = $this->convertHTMLColorToDec($svgstyle['fill']);
				if ($svgstyle['fill-opacity'] != 1) {
					$this->SetAlpha($svgstyle['fill-opacity']);
				}
				$this->SetFillColorArray($fill_color);
				if ($svgstyle['fill-rule'] == 'evenodd') {
					$objstyle .= 'F*';
				} else {
					$objstyle .= 'F';
				}
			}
			// stroke
			if ($svgstyle['stroke'] != 'none') {
				$stroke_style = array(
					'color' => $this->convertHTMLColorToDec($svgstyle['stroke']),
					'width' => $this->getHTMLUnitToUnits($svgstyle['stroke-width'], 0, $this->svgunit, false),
					'cap' => $svgstyle['stroke-linecap'],
					'join' => $svgstyle['stroke-linejoin']
					);
				if (isset($svgstyle['stroke-dasharray']) AND !empty($svgstyle['stroke-dasharray']) AND ($svgstyle['stroke-dasharray'] != 'none')) {
					$stroke_style['dash'] = $svgstyle['stroke-dasharray'];
				}
				$this->SetLineStyle($stroke_style);
				$objstyle .= 'D';
			}
			// font
			$regs = array();
			if (!empty($svgstyle['font'])) {
				if (preg_match('/font-family[\s]*:[\s]*([^\s\;\"]*)/si', $svgstyle['font'], $regs)) {
					$font_family = trim($regs[1]);
				} else {
					$font_family = $svgstyle['font-family'];
				}
				if (preg_match('/font-size[\s]*:[\s]*([^\s\;\"]*)/si', $svgstyle['font'], $regs)) {
					$font_size = trim($regs[1]);
				} else {
					$font_size = $svgstyle['font-size'];
				}
				if (preg_match('/font-style[\s]*:[\s]*([^\s\;\"]*)/si', $svgstyle['font'], $regs)) {
					$font_style = trim($regs[1]);
				} else {
					$font_style = $svgstyle['font-style'];
				}
				if (preg_match('/font-weight[\s]*:[\s]*([^\s\;\"]*)/si', $svgstyle['font'], $regs)) {
					$font_weight = trim($regs[1]);
				} else {
					$font_weight = $svgstyle['font-weight'];
				}
			} else {
				$font_family = $svgstyle['font-family'];
				$font_size = $svgstyle['font-size'];
				$font_style = $svgstyle['font-style'];
				$font_weight = $svgstyle['font-weight'];
			}
			$font_size = $this->getHTMLUnitToUnits($font_size, $prevsvgstyle['font-size'], $this->svgunit, false) * $this->k;
			switch ($font_style) {
				case 'italic': {
					$font_style = 'I';
					break;
				}
				case 'oblique': {
					$font_style = 'I';
					break;
				}
				default:
				case 'normal': {
					$font_style = '';
					break;
				}
			}
			switch ($font_weight) {
				case 'bold':
				case 'bolder': {
					$font_style .= 'B';
					break;
				}
			}
			switch ($svgstyle['text-decoration']) {
				case 'underline': {
					$font_style .= 'U';
					break;
				}
				case 'overline': {
					$font_style .= 'O';
					break;
				}
				case 'line-through': {
					$font_style .= 'D';
					break;
				}
				default:
				case 'none': {
					break;
				}
			}
			$this->SetFont($font_family, $font_style, $font_size);
			return $objstyle;
		}

		/**
		 * Draws an SVG path
		 * @param string $d attribute d of the path SVG element
		 * @param string $style Style of rendering. Possible values are:
		 * 

		 *	 
D or empty string: Draw (default).
		 *	 
F: Fill.
		 *	 
F*: Fill using the even-odd rule to determine which regions lie inside the clipping path.
		 *	 
DF or FD: Draw and fill.
		 *	 
DF* or FD*: Draw and fill using the even-odd rule to determine which regions lie inside the clipping path.
		 *	 
CNZ: Clipping mode (using the even-odd rule to determine which regions lie inside the clipping path).
		 *	 
CEO: Clipping mode (using the nonzero winding number rule to determine which regions lie inside the clipping path).
		 * 
		 * @return array of container box measures (x, y, w, h)
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function SVGPath($d, $style='') {
			// set fill/stroke style
			$op = $this->getPathPaintOperator($style, '');
			if (empty($op)) {
				return;
			}
			$paths = array();
			preg_match_all('/([a-zA-Z])[\s]*([^a-zA-Z\"]*)/si', $d, $paths, PREG_SET_ORDER);
			$x = 0;
			$y = 0;
			$x1 = 0;
			$y1 = 0;
			$x2 = 0;
			$y2 = 0;
			$xmin = 2147483647;
			$xmax = 0;
			$ymin = 2147483647;
			$ymax = 0;
			$relcoord = false;
			// draw curve pieces
			foreach ($paths as $key => $val) {
				// get curve type
				$cmd = trim($val[1]);
				if (strtolower($cmd) == $cmd) {
					// use relative coordinated instead of absolute
					$relcoord = true;
					$xoffset = $x;
					$yoffset = $y;
				} else {
					$relcoord = false;
					$xoffset = 0;
					$yoffset = 0;
				}
				$params = array();
				if (isset($val[2])) {
					// get curve parameters
					$rawparams = preg_split('/([\,\s]+)/si', trim($val[2]));
					$params = array();
					foreach ($rawparams as $ck => $cp) {
						$params[$ck] = $this->getHTMLUnitToUnits($cp, 0, $this->svgunit, false);
					}
				}
				switch (strtoupper($cmd)) {
					case 'M': { // moveto
						foreach ($params as $ck => $cp) {
							if (($ck % 2) == 0) {
								$x = $cp + $xoffset;
							} else {
								$y = $cp + $yoffset;
								if ($ck == 1) {
									$this->_outPoint($x, $y);
								} else {
									$this->_outLine($x, $y);
								}
								$xmin = min($xmin, $x);
								$ymin = min($ymin, $y);
								$xmax = max($xmax, $x);
								$ymax = max($ymax, $y);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'L': { // lineto
						foreach ($params as $ck => $cp) {
							if (($ck % 2) == 0) {
								$x = $cp + $xoffset;
							} else {
								$y = $cp + $yoffset;
								$this->_outLine($x, $y);
								$xmin = min($xmin, $x);
								$ymin = min($ymin, $y);
								$xmax = max($xmax, $x);
								$ymax = max($ymax, $y);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'H': { // horizontal lineto
						foreach ($params as $ck => $cp) {
							$x = $cp + $xoffset;
							$this->_outLine($x, $y);
							$xmin = min($xmin, $x);
							$xmax = max($xmax, $x);
							if ($relcoord) {
								$xoffset = $x;
							}
						}
						break;
					}
					case 'V': { // vertical lineto
						foreach ($params as $ck => $cp) {
							$y = $cp + $yoffset;
							$this->_outLine($x, $y);
							$ymin = min($ymin, $y);
							$ymax = max($ymax, $y);
							if ($relcoord) {
								$yoffset = $y;
							}
						}
						break;
					}
					case 'C': { // curveto
						foreach ($params as $ck => $cp) {
							$params[$ck] = $cp;
							if ((($ck + 1) % 6) == 0) {
								$x1 = $params[($ck - 5)] + $xoffset;
								$y1 = $params[($ck - 4)] + $yoffset;
								$x2 = $params[($ck - 3)] + $xoffset;
								$y2 = $params[($ck - 2)] + $yoffset;
								$x = $params[($ck - 1)] + $xoffset;
								$y = $params[($ck)] + $yoffset;
								$this->_outCurve($x1, $y1, $x2, $y2, $x, $y);
								$xmin = min($xmin, $x, $x1, $x2);
								$ymin = min($ymin, $y, $y1, $y2);
								$xmax = max($xmax, $x, $x1, $x2);
								$ymax = max($ymax, $y, $y1, $y2);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'S': { // shorthand/smooth curveto
						foreach ($params as $ck => $cp) {
							$params[$ck] = $cp;
							if ((($ck + 1) % 4) == 0) {
								if (($key > 0) AND ((strtoupper($paths[($key - 1)][1]) == 'C') OR (strtoupper($paths[($key - 1)][1]) == 'S'))) {
									$x1 = (2 * $x) - $x2;
									$y1 = (2 * $y) - $y2;
								} else {
									$x1 = $x;
									$y1 = $y;
								}
								$x2 = $params[($ck - 3)] + $xoffset;
								$y2 = $params[($ck - 2)] + $yoffset;
								$x = $params[($ck - 1)] + $xoffset;
								$y = $params[($ck)] + $yoffset;
								$this->_outCurve($x1, $y1, $x2, $y2, $x, $y);
								$xmin = min($xmin, $x, $x1, $x2);
								$ymin = min($ymin, $y, $y1, $y2);
								$xmax = max($xmax, $x, $x1, $x2);
								$ymax = max($ymax, $y, $y1, $y2);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'Q': { // quadratic Bézier curveto
						foreach ($params as $ck => $cp) {
							$params[$ck] = $cp;
							if ((($ck + 1) % 4) == 0) {
								// convert quadratic points to cubic points
								$x1 = $params[($ck - 3)] + $xoffset;
								$y1 = $params[($ck - 2)] + $yoffset;
								$xa = ($x + (2 * $x1)) / 3;
								$ya = ($y + (2 * $y1)) / 3;
								$x = $params[($ck - 1)] + $xoffset;
								$y = $params[($ck)] + $yoffset;
								$xb = ($x + (2 * $x1)) / 3;
								$yb = ($y + (2 * $y1)) / 3;
								$this->_outCurve($xa, $ya, $xb, $yb, $x, $y);
								$xmin = min($xmin, $x, $xa, $xb);
								$ymin = min($ymin, $y, $ya, $yb);
								$xmax = max($xmax, $x, $xa, $xb);
								$ymax = max($ymax, $y, $ya, $yb);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'T': { // shorthand/smooth quadratic Bézier curveto
						foreach ($params as $ck => $cp) {
							$params[$ck] = $cp;
							if (($ck % 2) != 0) {
								if (($key > 0) AND ((strtoupper($paths[($key - 1)][1]) == 'Q') OR (strtoupper($paths[($key - 1)][1]) == 'T'))) {
									$x1 = (2 * $x) - $x1;
									$y1 = (2 * $y) - $y1;
								} else {
									$x1 = $x;
									$y1 = $y;
								}
								// convert quadratic points to cubic points
								$xa = ($x + (2 * $x1)) / 3;
								$ya = ($y + (2 * $y1)) / 3;
								$x = $params[($ck - 1)] + $xoffset;
								$y = $params[($ck)] + $yoffset;
								$xb = ($x + (2 * $x1)) / 3;
								$yb = ($y + (2 * $y1)) / 3;
								$this->_outCurve($xa, $ya, $xb, $yb, $x, $y);
								$xmin = min($xmin, $x, $x1, $x2);
								$ymin = min($ymin, $y, $y1, $y2);
								$xmax = max($xmax, $x, $x1, $x2);
								$ymax = max($ymax, $y, $y1, $y2);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'A': { // elliptical arc
						foreach ($params as $ck => $cp) {
							$params[$ck] = $cp;
							if ((($ck + 1) % 7) == 0) {
								$x0 = $x;
								$y0 = $y;
								$rx = abs($params[($ck - 6)]);
								$ry = abs($params[($ck - 5)]);
								$ang = -$rawparams[($ck - 4)];
								$angle = deg2rad($ang);
								$fa = $rawparams[($ck - 3)]; // large-arc-flag
								$fs = $rawparams[($ck - 2)]; // sweep-flag
								$x = $params[($ck - 1)] + $xoffset;
								$y = $params[$ck] + $yoffset;
								$cos_ang = cos($angle);
								$sin_ang = sin($angle);
								$a = ($x0 - $x) / 2;
								$b = ($y0 - $y) / 2;
								$xa = ($a * $cos_ang) - ($b * $sin_ang);
								$ya = ($a * $sin_ang) + ($b * $cos_ang);
								$rx2 = $rx * $rx;
								$ry2 = $ry * $ry;
								$xa2 = $xa * $xa;
								$ya2 = $ya * $ya;
								$delta = ($xa2 / $rx2) + ($ya2 / $ry2);
								if ($delta > 1) {
									$rx *= sqrt($delta);
									$ry *= sqrt($delta);
									$rx2 = $rx * $rx;
									$ry2 = $ry * $ry;
								}
								$numerator = (($rx2 * $ry2) - ($rx2 * $ya2) - ($ry2 * $xa2));
								if ($numerator < 0) {
									$root = 0;
								} else {
									$root = sqrt($numerator / (($rx2 * $ya2) + ($ry2 * $xa2)));
								}
								if ($fa == $fs) {
									$root *= -1;
								}
								$cax = $root * (($rx * $ya) / $ry);
								$cay = -$root * (($ry * $xa) / $rx);
								// coordinates of ellipse center
								$cx = ($cax * $cos_ang) - ($cay * $sin_ang) + (($x0 + $x) / 2);
								$cy = ($cax * $sin_ang) + ($cay * $cos_ang) + (($y0 + $y) / 2);
								// get angles
								$angs = $this->getVectorsAngle(1, 0, (($xa - $cax) / $rx), (($cay - $ya) / $ry));
								$dang = $this->getVectorsAngle((($xa - $cax) / $rx), (($ya - $cay) / $ry), ((-$xa - $cax) / $rx), ((-$ya - $cay) / $ry));
								if (($fs == 0) AND ($dang > 0)) {
									$dang -= (2 * M_PI);
								} elseif (($fs == 1) AND ($dang < 0)) {
									$dang += (2 * M_PI);
								}
								$angf = $angs - $dang;
								if (($fs == 1) AND ($angs > $angf)) {
									$tmp = $angs;
									$angs = $angf;
									$angf = $tmp;
								}
								$angs = rad2deg($angs);
								$angf = rad2deg($angf);
								$pie = false;
								if ((isset($paths[($key + 1)][1])) AND (trim($paths[($key + 1)][1]) == 'z')) {
									$pie = true;
								}
								$this->_outellipticalarc($cx, $cy, $rx, $ry, $ang, $angs, $angf, $pie, 2);
								$this->_outPoint($x, $y);
								$xmin = min($xmin, $x);
								$ymin = min($ymin, $y);
								$xmax = max($xmax, $x);
								$ymax = max($ymax, $y);
								if ($relcoord) {
									$xoffset = $x;
									$yoffset = $y;
								}
							}
						}
						break;
					}
					case 'Z': {
						$this->_out('h');
						break;
					}
				}
			} // end foreach
			if (!empty($op)) {
				$this->_out($op);
			}
			return array($xmin, $ymin, ($xmax - $xmin), ($ymax - $ymin));
		}

		/**
		 * Returns the angle in  radiants between two vectors
		 * @param int $x1 X coordiante of first vector point
		 * @param int $y1 Y coordiante of first vector point
		 * @param int $x2 X coordiante of second vector point
		 * @param int $y2 Y coordiante of second vector point
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-04)
		 * @access protected
		 */
		protected function getVectorsAngle($x1, $y1, $x2, $y2) {
			$dprod = ($x1 * $x2) + ($y1 * $y2);
			$dist1 = sqrt(($x1 * $x1) + ($y1 * $y1));
			$dist2 = sqrt(($x2 * $x2) + ($y2 * $y2));
			$angle = acos($dprod / ($dist1 * $dist2));
			if (is_nan($angle)) {
				$angle = M_PI;
			}
			if ((($x1 * $y2) - ($x2 * $y1)) < 0) {
				$angle *= -1;
			}
			return $angle;
		}

		/**
		 * Sets the opening SVG element handler function for the XML parser. (*** TO BE COMPLETED ***)
		 * @param resource $parser The first parameter, parser, is a reference to the XML parser calling the handler.
		 * @param string $name The second parameter, name, contains the name of the element for which this handler is called. If case-folding is in effect for this parser, the element name will be in uppercase letters. 
		 * @param array $attribs The third parameter, attribs, contains an associative array with the element's attributes (if any). The keys of this array are the attribute names, the values are the attribute values. Attribute names are case-folded on the same criteria as element names. Attribute values are not case-folded. The original order of the attributes can be retrieved by walking through attribs the normal way, using each(). The first key in the array was the first attribute, and so on. 
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function startSVGElementHandler($parser, $name, $attribs) {
			// check if we are in clip mode
			if ($this->svgclipmode) {
				$this->svgclippaths[$this->svgclipid][] = array('name' => $name, 'attribs' => $attribs);
				return;
			}
			if ($this->svgdefsmode AND !in_array($name, array('clipPath', 'linearGradient', 'radialGradient', 'stop'))) {
				$this->svgdefs[$attribs['id']] = array('name' => $name, 'attribs' => $attribs);
				return;
			}
			$clipping = false;
			if ($parser == 'clip-path') {
				// set clipping mode
				$clipping = true;
			}
			// get styling properties
			$prev_svgstyle = $this->svgstyles[(count($this->svgstyles) - 1)]; // previous style
			$svgstyle = array(); // current style
			if (isset($attribs['style'])) {
				$attribs['style'] = ';'.$attribs['style'];
			}
			foreach ($prev_svgstyle as $key => $val) {
				if (isset($attribs[$key])) {
					if ($attribs[$key] == 'inherit') {
						$svgstyle[$key] = $val;
					} else {
						$svgstyle[$key] = $attribs[$key];
					}
				} elseif (isset($attribs['style'])) {
					// CSS style syntax
					$attrval = array();
					if (preg_match('/[;\"\s]{1}'.$key.'[\s]*:[\s]*([^;\"\s]*)/si', $attribs['style'], $attrval) AND isset($attrval[1])) {
						if ($attrval[1] == 'inherit') {
							$svgstyle[$key] = $val;
						} else {
							$svgstyle[$key] = $attrval[1];
						}
					} else {
						// default value
						$svgstyle[$key] = $this->svgstyles[0][$key];
					}
				} else {
					if (in_array($key, $this->svginheritprop)) {
						// inherit previous value
						$svgstyle[$key] = $val;
					} else {
						// default value
						$svgstyle[$key] = $this->svgstyles[0][$key];
					}
				}
			}
			// transformation matrix
			$tm = $this->svgstyles[(count($this->svgstyles) - 1)]['transfmatrix'];
			if (isset($attribs['transform']) AND !empty($attribs['transform'])) {
				$tm = $this->getTransformationMatrixProduct($tm, $this->getSVGTransformMatrix($attribs['transform']));
			}
			$svgstyle['transfmatrix'] = $tm;
			// process tag
			switch($name) {
				case 'defs': {
					$this->svgdefsmode = true;
					break;
				}
				// clipPath
				case 'clipPath': {
					$this->svgclipmode = true;
					$this->svgclipid = $attribs['id'];
					$this->svgclippaths[$this->svgclipid] = array();
					break;
				}
				case 'svg': {
					// start of SVG object
					break;
				}
				case 'g': {
					// group together related graphics elements
					array_push($this->svgstyles, $svgstyle);
					$this->StartTransform();
					$this->setSVGStyles($svgstyle, $prev_svgstyle);
					break;
				}
				case 'linearGradient': {
					$this->svggradientid = $attribs['id'];
					$this->svggradients[$this->svggradientid] = array();
					$this->svggradients[$this->svggradientid]['type'] = 2;
					$this->svggradients[$this->svggradientid]['stops'] = array();
					if (isset($attribs['gradientUnits'])) {
						$this->svggradients[$this->svggradientid]['gradientUnits'] = $attribs['gradientUnits'];
					} else {
						$this->svggradients[$this->svggradientid]['gradientUnits'] = 'objectBoundingBox';
					}
					//$attribs['spreadMethod']
					$x1 = (isset($attribs['x1'])?$attribs['x1']:0);
					$y1 = (isset($attribs['y1'])?$attribs['y1']:0);
					$x2 = (isset($attribs['x2'])?$attribs['x2']:1);
					$y2 = (isset($attribs['y2'])?$attribs['y2']:0);
					if (isset($attribs['x1']) AND (substr($attribs['x1'], -1) != '%')) {
						$this->svggradients[$this->svggradientid]['mode'] = 'measure';
					} else {
						$this->svggradients[$this->svggradientid]['mode'] = 'percentage';
					}
					if (isset($attribs['gradientTransform'])) {
						$this->svggradients[$this->svggradientid]['gradientTransform'] = $this->getSVGTransformMatrix($attribs['gradientTransform']);
					}
					$this->svggradients[$this->svggradientid]['coords'] = array($x1, $y1, $x2, $y2);
					if (isset($attribs['xlink:href']) AND !empty($attribs['xlink:href'])) {
						// gradient is defined on another place
						$this->svggradients[$this->svggradientid]['xref'] = substr($attribs['xlink:href'], 1);
					}
					break;
				}
				case 'radialGradient': {
					$this->svggradientid = $attribs['id'];
					$this->svggradients[$this->svggradientid] = array();
					$this->svggradients[$this->svggradientid]['type'] = 3;
					$this->svggradients[$this->svggradientid]['stops'] = array();
					if (isset($attribs['gradientUnits'])) {
						$this->svggradients[$this->svggradientid]['gradientUnits'] = $attribs['gradientUnits'];
					} else {
						$this->svggradients[$this->svggradientid]['gradientUnits'] = 'objectBoundingBox';
					}
					//$attribs['spreadMethod']
					$cx = (isset($attribs['cx'])?$attribs['cx']:0.5);
					$cy = (isset($attribs['cy'])?$attribs['cy']:0.5);
					$fx = (isset($attribs['fx'])?$attribs['fx']:$cx);
					$fy = (isset($attribs['fy'])?$attribs['fy']:$cy);
					$r = (isset($attribs['r'])?$attribs['r']:0.5);
					if (isset($attribs['cx']) AND (substr($attribs['cx'], -1) != '%')) {
						$this->svggradients[$this->svggradientid]['mode'] = 'measure';
					} else {
						$this->svggradients[$this->svggradientid]['mode'] = 'percentage';
					}
					if (isset($attribs['gradientTransform'])) {
						$this->svggradients[$this->svggradientid]['gradientTransform'] = $this->getSVGTransformMatrix($attribs['gradientTransform']);
					}
					$this->svggradients[$this->svggradientid]['coords'] = array($cx, $cy, $fx, $fy, $r);
					if (isset($attribs['xlink:href']) AND !empty($attribs['xlink:href'])) {
						// gradient is defined on another place
						$this->svggradients[$this->svggradientid]['xref'] = substr($attribs['xlink:href'], 1);
					}
					break;
				}
				case 'stop': {
					// gradient stops
					if (substr($attribs['offset'], -1) == '%') {
						$offset = floatval(substr($attribs['offset'], -1)) / 100;
					} else {
						$offset = floatval($attribs['offset']);
						if ($offset > 1) {
							$offset /= 100;
						}
					}
					$stop_color = isset($svgstyle['stop-color'])?$this->convertHTMLColorToDec($svgstyle['stop-color']):'black';
					$opacity = isset($svgstyle['stop-opacity'])?$svgstyle['stop-opacity']:1;
					$this->svggradients[$this->svggradientid]['stops'][] = array('offset' => $offset, 'color' => $stop_color, 'opacity' => $opacity);
					break;
				}
				// paths
				case 'path': {
					$d = trim($attribs['d']);
					if ($clipping) {
						$this->SVGTransform($tm);
						$this->SVGPath($d, 'CNZ');
					} else {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, 0, 0, 1, 1, 'SVGPath', array($d, 'CNZ'));
						if (!empty($obstyle)) {
							$this->SVGPath($d, $obstyle);
						}
						$this->StopTransform();
					}
					break;
				}
				// shapes
				case 'rect': {
					$x = (isset($attribs['x'])?$this->getHTMLUnitToUnits($attribs['x'], 0, $this->svgunit, false):0);
					$y = (isset($attribs['y'])?$this->getHTMLUnitToUnits($attribs['y'], 0, $this->svgunit, false):0);
					$w = (isset($attribs['width'])?$this->getHTMLUnitToUnits($attribs['width'], 0, $this->svgunit, false):0);
					$h = (isset($attribs['height'])?$this->getHTMLUnitToUnits($attribs['height'], 0, $this->svgunit, false):0);
					$rx = (isset($attribs['rx'])?$this->getHTMLUnitToUnits($attribs['rx'], 0, $this->svgunit, false):0);
					$ry = (isset($attribs['ry'])?$this->getHTMLUnitToUnits($attribs['ry'], 0, $this->svgunit, false):$rx);
					if ($clipping) {
						$this->SVGTransform($tm);
						$this->RoundedRectXY($x, $y, $w, $h, $rx, $ry, '1111', 'CNZ', array(), array());
					} else {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h, 'RoundedRectXY', array($x, $y, $w, $h, $rx, $ry, '1111', 'CNZ'));
						if (!empty($obstyle)) {
							$this->RoundedRectXY($x, $y, $w, $h, $rx, $ry, '1111', $obstyle, array(), array());
						}
						$this->StopTransform();
					}
					break;
				}
				case 'circle': {
					$cx = (isset($attribs['cx'])?$this->getHTMLUnitToUnits($attribs['cx'], 0, $this->svgunit, false):0);
					$cy = (isset($attribs['cy'])?$this->getHTMLUnitToUnits($attribs['cy'], 0, $this->svgunit, false):0);
					$r = (isset($attribs['r'])?$this->getHTMLUnitToUnits($attribs['r'], 0, $this->svgunit, false):0);
					$x = $cx - $r;
					$y = $cy - $r;
					$w = 2 * $r;
					$h = $w;
					if ($clipping) {
						$this->SVGTransform($tm);
						$this->Circle($cx, $cy, $r, 0, 360, 'CNZ', array(), array(), 8);
					} else {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h, 'Circle', array($cx, $cy, $r, 0, 360, 'CNZ'));
						if (!empty($obstyle)) {
							$this->Circle($cx, $cy, $r, 0, 360, $obstyle, array(), array(), 8);
						}
						$this->StopTransform();
					}
					break;
				}
				case 'ellipse': {
					$cx = (isset($attribs['cx'])?$this->getHTMLUnitToUnits($attribs['cx'], 0, $this->svgunit, false):0);
					$cy = (isset($attribs['cy'])?$this->getHTMLUnitToUnits($attribs['cy'], 0, $this->svgunit, false):0);
					$rx = (isset($attribs['rx'])?$this->getHTMLUnitToUnits($attribs['rx'], 0, $this->svgunit, false):0);
					$ry = (isset($attribs['ry'])?$this->getHTMLUnitToUnits($attribs['ry'], 0, $this->svgunit, false):0);
					$x = $cx - $rx;
					$y = $cy - $ry;
					$w = 2 * $rx;
					$h = 2 * $ry;
					if ($clipping) {
						$this->SVGTransform($tm);
						$this->Ellipse($cx, $cy, $rx, $ry, 0, 0, 360, 'CNZ', array(), array(), 8);
					} else {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h, 'Ellipse', array($cx, $cy, $rx, $ry, 0, 0, 360, 'CNZ'));
						if (!empty($obstyle)) {
							$this->Ellipse($cx, $cy, $rx, $ry, 0, 0, 360, $obstyle, array(), array(), 8);
						}
						$this->StopTransform();
					}
					break;
				}
				case 'line': {
					$x1 = (isset($attribs['x1'])?$this->getHTMLUnitToUnits($attribs['x1'], 0, $this->svgunit, false):0);
					$y1 = (isset($attribs['y1'])?$this->getHTMLUnitToUnits($attribs['y1'], 0, $this->svgunit, false):0);
					$x2 = (isset($attribs['x2'])?$this->getHTMLUnitToUnits($attribs['x2'], 0, $this->svgunit, false):0);
					$y2 = (isset($attribs['y2'])?$this->getHTMLUnitToUnits($attribs['y2'], 0, $this->svgunit, false):0);
					$x = $x1;
					$y = $y1;
					$w = abs($x2 - $x1);
					$h = abs($y2 - $y1);
					if (!$clipping) {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h, 'Line', array($x1, $y1, $x2, $y2));
						$this->Line($x1, $y1, $x2, $y2);
						$this->StopTransform();
					}
					break;
				}
				case 'polyline':
				case 'polygon': {
					$points = (isset($attribs['points'])?$attribs['points']:'0 0');
					$points = trim($points);
					// note that point may use a complex syntax not covered here
					$points = preg_split('/[\,\s]+/si', $points);
					if (count($points) < 4) {
						break;
					}
					$p = array();
					$xmin = 2147483647;
					$xmax = 0;
					$ymin = 2147483647;
					$ymax = 0;
					foreach ($points as $key => $val) {
						$p[$key] = $this->getHTMLUnitToUnits($val, 0, $this->svgunit, false);
						if (($key % 2) == 0) {
							// X coordinate
							$xmin = min($xmin, $p[$key]);
							$xmax = max($xmax, $p[$key]);
						} else {
							// Y coordinate
							$ymin = min($ymin, $p[$key]);
							$ymax = max($ymax, $p[$key]);
						}
					}
					$x = $xmin;
					$y = $ymin;
					$w = ($xmax - $xmin);
					$h = ($ymax - $ymin);
					if ($name == 'polyline') {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h, 'PolyLine', array($p, 'CNZ'));
						$this->PolyLine($p, 'D', array(), array());
						$this->StopTransform();
					} else { // polygon
						if ($clipping) {
							$this->SVGTransform($tm);
							$this->Polygon($p, 'CNZ', array(), array(), true);
						} else {
							$this->StartTransform();
							$this->SVGTransform($tm);
							$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h, 'Polygon', array($p, 'CNZ'));
							if (!empty($obstyle)) {
								$this->Polygon($p, $obstyle, array(), array(), true);
							}
							$this->StopTransform();
						}
					}
					break;
				}
				// image
				case 'image': {
					if (!isset($attribs['xlink:href']) OR empty($attribs['xlink:href'])) {
						break;
					}
					$x = (isset($attribs['x'])?$this->getHTMLUnitToUnits($attribs['x'], 0, $this->svgunit, false):0);
					$y = (isset($attribs['y'])?$this->getHTMLUnitToUnits($attribs['y'], 0, $this->svgunit, false):0);
					$w = (isset($attribs['width'])?$this->getHTMLUnitToUnits($attribs['width'], 0, $this->svgunit, false):0);
					$h = (isset($attribs['height'])?$this->getHTMLUnitToUnits($attribs['height'], 0, $this->svgunit, false):0);
					$img = $attribs['xlink:href'];
					if (!$clipping) {
						$this->StartTransform();
						$this->SVGTransform($tm);
						$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, $w, $h);
						// fix image path
						if (!$this->empty_string($this->svgdir) AND (($img{0} == '.') OR (basename($img) == $img))) {
							// replace relative path with full server path
							$img = $this->svgdir.'/'.$img;
						}
						if (($img{0} == '/') AND ($_SERVER['DOCUMENT_ROOT'] != '/')) {
							$findroot = strpos($img, $_SERVER['DOCUMENT_ROOT']);
							if (($findroot === false) OR ($findroot > 1)) {
								// replace relative path with full server path
								$img = $_SERVER['DOCUMENT_ROOT'].$img;
							}
						}
						$img = urldecode($img);
						$testscrtype = @parse_url($img);
						if (!isset($testscrtype['query']) OR empty($testscrtype['query'])) {
							// convert URL to server path
							$img = str_replace(K_PATH_URL, K_PATH_MAIN, $img);
						}
						$this->Image($img, $x, $y, $w, $h);
						$this->StopTransform();
					}
					break;
				}
				// text
				case 'text':
				case 'tspan': {
					// only basic support - advanced features must be implemented
					$x = (isset($attribs['x'])?$this->getHTMLUnitToUnits($attribs['x'], 0, $this->svgunit, false):0);
					$y = (isset($attribs['y'])?$this->getHTMLUnitToUnits($attribs['y'], 0, $this->svgunit, false):0);
					$svgstyle['text-color'] = $svgstyle['fill'];
					$this->svgtext = '';
					$this->StartTransform();
					$this->SVGTransform($tm);
					$obstyle = $this->setSVGStyles($svgstyle, $prev_svgstyle, $x, $y, 1, 1);
					$this->SetXY($x, $y, true);
					break;
				}
				// use
				case 'use': {
					if (isset($attribs['xlink:href'])) {
						$use = $this->svgdefs[substr($attribs['xlink:href'], 1)];
						if (isset($attribs['xlink:href'])) {
							unset($attribs['xlink:href']);
						}
						if (isset($attribs['id'])) {
							unset($attribs['id']);
						}
						$attribs = array_merge($use['attribs'], $attribs);
						$this->startSVGElementHandler($parser, $use['name'], $use['attribs']);
					}
					break;
				}
				default: {
					break;
				}
			}
		}

		/**
		 * Sets the closing SVG element handler function for the XML parser.
		 * @param resource $parser The first parameter, parser, is a reference to the XML parser calling the handler.
		 * @param string $name The second parameter, name, contains the name of the element for which this handler is called. If case-folding is in effect for this parser, the element name will be in uppercase letters. 
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function endSVGElementHandler($parser, $name) {
			switch($name) {
				case 'defs': {
					$this->svgdefsmode = false;
					break;
				}
				// clipPath
				case 'clipPath': {
					$this->svgclipmode = false;
					break;
				}
				case 'g': {
					// ungroup: remove last style from array
					array_pop($this->svgstyles);
					$this->StopTransform();
					break;
				}
				case 'text':
				case 'tspan': {
					// print text
					$this->Cell(0, 0, trim($this->svgtext), 0, 0, '', 0, '', 0, false, 'L', 'T');
					$this->StopTransform();
					break;
				}
				default: {
					break;
				}
			}
		}

		/**
		 * Sets the character data handler function for the XML parser.
		 * @param resource $parser The first parameter, parser, is a reference to the XML parser calling the handler.
		 * @param string $data The second parameter, data, contains the character data as a string. 
		 * @author Nicola Asuni
		 * @since 5.0.000 (2010-05-02)
		 * @access protected
		 */
		protected function segSVGContentHandler($parser, $data) {
			$this->svgtext .= $data;
		}

	} // END OF TCPDF CLASS
}
//============================================================+
// END OF FILE
//============================================================+
?>