'] = $options['tableStyle'];
$this->log->info( '"tableStyle" option is DEPRECATED, use "wordStyles" instead. ' );
}
if (isset($options['paragraphStyle'])) { //FIXME deprecated
//$this->paragraphStyle = $options['paragraphStyle'];
$this->wordStyles[''] = $options['paragraphStyle'];
$this->log->info( '"paragraphStyle" option is DEPRECATED, use "wordStyles" instead. ' );
}
if (isset($options['strictWordStyles'])) {
$this->strictWordStyles = $options['strictWordStyles'];
}
if (isset($options['wordStyles']) && is_array($options['wordStyles'])) {
if(empty($this->wordStyles)){
$this->wordStyles = $options['wordStyles'];
}
else{ //FIXME change this when "tableStyle" and "paragraphStyle" dissapears
foreach($options['wordStyles'] as $key => $value){
$this->wordStyles[$key] = $value;
}
}
}
if (isset($options['downloadImages'])) {
$this->downloadImages = $options['downloadImages'];
}
$filter = isset($options['filter']) ? $options['filter'] : '*';
$dompdfTree = $this->renderDompdf($html, $this->isFile, $filter, $this->parseDivs);
$this->_render($dompdfTree);
if (self::$openPs) {
self::$WordML .= '';
}
self::$WordML = $this->repairWordML(self::$WordML);
return(array(self::$WordML, self::$linkTargets, self::$linkImages, self::$orderedLists));
}
/**
* Get the HTML DOM tree from DOMPDF
*
* @access private
* @param string $html
* @param boolean $isFile
* @param string $filter
* @return array
*/
private function renderDompdf($html, $isFile = false, $filter = '*', $parseDivs = false) {
/*require_once(DIR_DOMPDF . "/dompdf_config.inc.php");
require_once(DOMPDF_INC_DIR . '/dompdf_treeOut.php');
$dompdf = new dompdf_treeOut();*/
require_once(DIR_PARSER. '/parserhtml_config.inc.php');
$dompdf = new PARSERHTML();
$aTemp = $dompdf->getDompdfTree($html, $isFile, $filter, $parseDivs);
return($aTemp);
}
/**
* This function renders the HTML DOM elements recursively
*
* @access private
* @param array $nodo
* @param integer $depth
* @return array
*/
private function _render($nodo, $depth=0) {
$this->_level = $depth;
if(isset($nodo['attributes']['id']) && $this->parseAnchors){
$bookmarkId = rand(999999, 99999999);
self::$WordML .= '';
}
$properties = isset($nodo['properties']) ? $nodo['properties'] : array();
switch ($nodo['nodeName']) {
case 'div':
if (!$this->parseDivs) {
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
break;
}
case 'h1':
case 'h2':
case 'h3':
case 'h4':
case 'h5':
case 'h6':
case 'p':
case 'dt':
case 'dd':
// extract the heading level
$level = substr($nodo['nodeName'], 1, 1);
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if (self::$openPs) {
if (self::$openLinks) {
self::$WordML .= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
self::$WordML .= '';
} else {
self::$WordML .= '';
self::$openPs = true;
}
self::$WordML .= $this->generatePPr($properties, $level, $nodo['attributes'], $nodo['nodeName'] );
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'dl':
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'ol':
createDocx::$numOL++;
self::$orderedLists[] = createDocx::$numOL;
case 'ul':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'li':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if (self::$openPs) {
if (self::$openLinks) {
self::$WordML .= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
self::$WordML .= '';
} else {
self::$WordML .= '';
self::$openPs = true;
}
self::$openTags[$depth] = $nodo['nodeName'];
self::$WordML .= $this->generateListPr($properties);
break;
case 'table':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTable++;
self::$tableGrid[self::$openTable] = array();
if (self::$openPs) {
if (self::$openLinks) {
self::$WordML .= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
if (self::$openBr){
self::$WordML .= '';
for($j =0; $j < self::$openBr; $j++){
self::$WordML .= '';
}
self::$WordML .= '';
self::$openBr = 0;
}
self::$WordML .= '';
self::$openPs = false;
} else {
self::$WordML .= '';
}
self::$WordML .= $this->generateTblPr($properties, $nodo['attributes'] );
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'tr':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
array_push(self::$tableGrid[self::$openTable], array());
self::$WordML .= '';
self::$WordML .= $this->generateTrPr($properties);
self::$openTags[$depth] = $nodo['nodeName'];
// Hack to circumvent the fact that in WordML it is not posible to give a background color to a whole row
self::$rowColor = $properties['background_color'];
break;
case 'th':
case 'td':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
$firstRow = $nodo['nodeName'] == 'th' ? true : false;
//Now we have to deal with posible rowspans coming from previous rows
$row = count(self::$tableGrid[self::$openTable]) - 1;
$column = count(self::$tableGrid[self::$openTable][$row]);
$this->countEmptyColumns($row, $column);
//Now we have to deal with the current td
$colspan = (int) $nodo['attributes']['colspan'];
$rowspan = (int) $nodo['attributes']['rowspan'];
self::$WordML .= '';
for ($k = 0; $k < $colspan; $k++) {
array_push(self::$tableGrid[self::$openTable][count(self::$tableGrid[self::$openTable]) - 1], array($rowspan, $colspan - $k));
}
self::$WordML .= $this->generateTcPr($properties, $colspan, $rowspan, $firstRow);
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'a':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if (isset($nodo['attributes']['href']) && $nodo['attributes']['href'] != '' ) {//FIXME: by the time being we do not parse anchors
$aId = 'rId' . uniqid(true);
if (self::$openPs) {
if($nodo['attributes']['href'][0] != '#'){
self::$openLinks = true;
self::$WordML .= '';
self::$linkTargets[$aId] = htmlspecialchars($this->parseURL($nodo['attributes']['href']));
}else if ($nodo['attributes']['href'][0] == '#' && $this->parseAnchors){
self::$openLinks = true;
self::$WordML .= '';
}
} else {
if($nodo['attributes']['href'][0] != '#'){
self::$openLinks = true;
self::$WordML .= '';
self::$linkTargets[$aId] = htmlspecialchars($this->parseURL($nodo['attributes']['href']));
self::$openPs = true;
}else if ($nodo['attributes']['href'][0] == '#' && $this->parseAnchors){
self::$openLinks = true;
self::$WordML .= '';
self::$openPs = true;
}
}
}else if (isset($nodo['attributes']['name']) && $nodo['attributes']['name'] != '' && $this->parseAnchors){
$tempId = rand(999999999, 9999999999999);
self::$WordML .= '';
self::$openBookmark = $tempId;
}
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'sub':
if($nodo['nodeName'] == 'sub') {self::$openScript = 'subscript';}
case 'sup':
if($nodo['nodeName'] == 'sup') {self::$openScript = 'superscript';}
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
break;
case '#text':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if(self::$openSelect){
if(count(self::$selectOptions) < 25){
if(self::$selectedOption){
array_unshift(self::$selectOptions, htmlspecialchars($nodo['nodeValue']));
}else{
self::$selectOptions[] = htmlspecialchars($nodo['nodeValue']);
}
}else{
echo 'The 25 limit of items that Word has stablished for a dropdown list has been exceeded'.PHP_EOL;
}
}else if(self::$openTextArea){
self::$textArea = htmlspecialchars($nodo['nodeValue']);
}else{
if (self::$openPs) {
self::$WordML .= '';
} else {
self::$WordML .= '';
// if we are creating the paragraph by hand we have to take care of certain styles
// that are important to keep like inherited justification
$style = array();
if(@$properties['text_align'] != '' || @$properties['text_align'] != 'left'){
$style['text_align'] = $properties['text_align'];
}
if(!empty($style)) self::$WordML .= $this->generatePPr($style);
self::$WordML .= '';
self::$openPs = true;
}
self::$WordML .= $this->generateRPr($properties);
if(self::$openBr){
for($j =0; $j < self::$openBr; $j++){
self::$WordML .= '';
}
self::$openBr = 0;
}
self::$WordML .= '' . htmlspecialchars($nodo['nodeValue']) . '';
self::$WordML .= '';
}
self::$openTags[$depth] = $nodo['nodeName'];
break;
case 'br':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if (self::$openPs) {
self::$openBr++;
} else {
self::$WordML .= '';
}
break;
case 'img':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
//We first check if the image has an allowed extension
$descrArray = explode('/',$nodo['attributes']['src']);
$arrayExtension = explode('.', $this->parseURL($nodo['attributes']['src']));
$descr = array_pop($descrArray);
$descr = array_shift(explode('?', $descr));
$extension = strtolower(array_pop($arrayExtension));
$extension = array_shift(explode('?', $extension));
$predefinedExtensions = explode(',', ALLOWED_IMAGE_EXT);
$hiddenExtension = '';
if (!in_array($extension, $predefinedExtensions)){
$extensionId = exif_imagetype($this->parseURL($nodo['attributes']['src']));
$extensionArray = array();
$extensionArray[1] = 'gif';
$extensionArray[2] = 'jpg';
$extensionArray[3] = 'png';
$extensionArray[6] = 'bmp';
$extension = $extensionArray[$extensionId];
$hiddenExtension = $extension;
}
if (!in_array($extension, $predefinedExtensions)){
continue;
}
$photo = @file_get_contents($this->parseURL($nodo['attributes']['src']));
if(!$photo) continue;
if (self::$openPs) {
self::$WordML .= '';
} else {
self::$WordML .= '';
self::$WordML .= '';
self::$openPs = true;
}
self::$WordML .= $this->generateRPr($properties);
self::$openTags[$depth] = $nodo['nodeName'];
$imgId = 'rId' . uniqid(true);
$tempName = 'name' . uniqid(true);
//We get the photos to parse their properties
if(!is_dir(self::$pathToBaseTemplate.'/word/mediaTemplate')){
mkdir(self::$pathToBaseTemplate.'/word/mediaTemplate');
}
$photoHandle = fopen(self::$pathToBaseTemplate.'/word/mediaTemplate/img'.$imgId.'.'.$extension, "w+");
$contents = fwrite($photoHandle, $photo);
fclose($photoHandle);
$size = getimagesize(self::$pathToBaseTemplate.'/word/mediaTemplate/img'.$imgId.'.'.$extension);
if(!$this->downloadImages){
unlink(self::$pathToBaseTemplate.'/word/mediaTemplate/img'.$imgId.'.'.$extension);
}
$c = $this->getImageDimensions($size, $nodo['attributes']);
$cx = $c[0];
$cy = $c[1];
//Now we will manage the image borders if any
if(isset($properties['border_top_style']) && $properties['border_top_style'] != 'none'){
$imageBorderWidth = $properties['border_top_width']*9600;
$imageBorderStyle = self::$imageBorderStyles[$properties['border_top_style']];
$imageBorderColor = $this->wordMLColor($properties['border_top_color']);
}else{
$imageBorderWidth = 0;
$imageBorderStyle = '';
$imageBorderColor = '';
}
//We now take care of paddings and margins
$distance = array();
foreach (self::$borders as $key => $value) {
$distance[$value] = $this->imageMargins($properties['margin_'.$value], $properties['padding_'.$value], $properties['font_size']);
}
if(isset($properties['float']) && ($properties['float'] == 'left' || $properties['float'] == 'right')){
$docPr = rand(99999, 99999999);
self::$WordML .= ''.$properties['float'].'40000';
if ($this->downloadImages) {
self::$WordML .= '';
} else {
self::$WordML .= '';
}
self::$WordML .= '';
self::$WordML .= $this->imageBorders($imageBorderWidth, $imageBorderStyle, $imageBorderColor);
self::$WordML .= '';
}else{
self::$WordML .= '';
if ($this->downloadImages) {
self::$WordML .= '';
} else {
self::$WordML .= '';
}
self::$WordML .= '';
self::$WordML .= $this->imageBorders($imageBorderWidth, $imageBorderStyle, $imageBorderColor);
self::$WordML .= '';
}
self::$WordML .= '';
if(empty($hiddenExtension)){
self::$linkImages[$imgId] = $this->parseURL($nodo['attributes']['src']);
}else{
self::$linkImages[$imgId] = $this->parseURL($nodo['attributes']['src']) . '.' . $hiddenExtension;
}
break;
case 'hr':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if(self::$openPs){
self::$WordML .= '';
}else{
self::$WordML .= '';
}
break;
case 'input':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
if(isset($nodo['attributes']['type']) && $nodo['attributes']['type'] =='text'){
if(self::$openPs){
//do not do anything
}else{
self::$WordML .= '';
// if we are creating the paragraph by hand we have to take care of certain styles
// that are important to keep like inherited justification
$style = array();
if(@$properties['text_align'] != '' || @$properties['text_align'] != 'left'){
$style['text_align'] = $properties['text_align'];
}
if(!empty($style)) self::$WordML .= $this->generatePPr($style);
self::$openPs = true;
}
//we check if there is a br open
if(self::$openBr){
self::$WordML .= '';
for($j =0; $j < self::$openBr; $j++){
self::$WordML .= '';
}
self::$openBr = 0;
self::$WordML .= '';
}
//Now we insert the corresponding XML
$bookmarkId = rand(99999,9999999);
$uniqueName = uniqid(true);
self::$WordML .= ' FORMTEXT ';
if(isset($nodo['attributes']['value']) && $nodo['attributes']['value'] !=''){
self::$WordML .= $nodo['attributes']['value'];
}else{
if(isset($nodo['attributes']['size']) && $nodo['attributes']['size'] > 0){
$size = $nodo['attributes']['size'];
}else{
$size = 18;
}
for($k =0; $k <= $size; $k++){
self::$WordML .=' '; //blank characters for Word
}
}
self::$WordML .=' ';
}else if(isset($nodo['attributes']['type']) && ($nodo['attributes']['type'] =='checkbox' || $nodo['attributes']['type'] =='radio')){
if(self::$openPs){
//do not do anything
}else{
self::$WordML .= '';
// if we are creating the paragraph by hand we have to take care of certain styles
// that are important to keep like inherited justification
$style = array();
if(@$properties['text_align'] != '' || @$properties['text_align'] != 'left'){
$style['text_align'] = $properties['text_align'];
}
if(!empty($style)) self::$WordML .= $this->generatePPr($style);
self::$openPs = true;
}
//Now we insert the corresponding XML
$bookmarkId = rand(99999,9999999);
$uniqueName = uniqid(true);
if(isset($nodo['attributes']['checked']) && $nodo['attributes']['checked']){
$selected = 1;
}else{
$selected = 0;
}
//we check if there is a br open
if(self::$openBr){
self::$WordML .= '';
for($j =0; $j < self::$openBr; $j++){
self::$WordML .= '';
}
self::$openBr = 0;
self::$WordML .= '';
}
self::$WordML .= ' FORMCHECKBOX ';
}
break;
case 'select':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
self::$selectOptions = array();
if(self::$openPs){
//do not do anything
}else{
self::$WordML .= '';
// if we are creating the paragraph by hand we have to take care of certain styles
// that are important to keep like inherited justification
$style = array();
if(@$properties['text_align'] != '' || @$properties['text_align'] != 'left'){
$style['text_align'] = $properties['text_align'];
}
if(!empty($style)) self::$WordML .= $this->generatePPr($style);
self::$openPs = true;
}
break;
case 'option':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
self::$openSelect = true;
if(isset($nodo['attributes']['selected']) && $nodo['attributes']['selected']){
self::$selectedOption = 1;
}else{
self::$selectedOption = 0;
}
break;
case 'textarea':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
self::$openTextArea = true;
if(self::$openPs){
//do not do anything
}else{
self::$WordML .= '';
// if we are creating the paragraph by hand we have to take care of certain styles
// that are important to keep like inherited justification
$style = array();
if(@$properties['text_align'] != '' || @$properties['text_align'] != 'left'){
$style['text_align'] = $properties['text_align'];
}
if(!empty($style)) self::$WordML .= $this->generatePPr($style);
self::$openPs = true;
}
break;
case 'samp':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
//we use this tag also for Word footnotes if the attribute title has the
//structure phpdocx_footnote_number or phpdocx_endnote_number
$title = $nodo['attributes']['title'];
$titArray = explode('_', $title);
if($titArray[0] == 'phpdocx'){
if($titArray[1] == 'footnote'){
self::$WordML .= '';
if (isset($properties['font_family']) && $properties['font_family'] != 'serif' && $properties['font_family'] != 'fixed') {
$arrayCSSFonts = explode(',', $properties['font_family']);
$font = trim($arrayCSSFonts[0]);
$font = str_replace('"', '', $font);
self::$WordML .= ' ';
}
if (@$properties['color'] != '' && is_array($properties['color'])) {
$color = $properties['color'];
$color = $this->wordMLColor($color);
self::$WordML .='';
}
self::$WordML .='';
}else if($titArray[1] == 'endnote'){
self::$WordML .= '';
if (isset($properties['font_family']) && $properties['font_family'] != 'serif') {
$arrayCSSFonts = explode(',', $properties['font_family']);
$font = trim($arrayCSSFonts[0]);
$font = str_replace('"', '', $font);
self::$WordML .= ' ';
}
if (@$properties['color'] != '' && is_array($properties['color'])) {
$color = $properties['color'];
$color = $this->wordMLColor($color);
self::$WordML .='';
}
self::$WordML .='';
}
}
break;
case 'close':
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
break;
default:
self::$WordML .= $this->closePreviousTags($depth, $nodo['nodeName']);
self::$openTags[$depth] = $nodo['nodeName'];
break;
}
++$depth;
if (!empty($nodo['children'])) {
foreach ($nodo['children'] as $child) {
$this->_render($child, $depth);
}
}
}
/**
* This function takes care that all nodes are properly closed
*
* @access private
* @param integer $depth
* @param string $currentTag
*/
private function closePreviousTags($depth, $currentTag = '') {
$sRet = '';
$counter = count(self::$openTags);
for ($j = $counter; $j >= $depth - 1; $j--) {
$tag = array_pop(self::$openTags);
switch ($tag) {
case 'div':
if (!$this->parseDivs)
break;
case 'h1':
case 'h2':
case 'h3':
case 'h4':
case 'h5':
case 'h6':
case 'p':
case 'dt':
case 'dd':
case 'li':
if (self::$openPs) {
if (self::$openLinks) {
$sRet.= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
$sRet .= '';
self::$openPs = false;
}
break;
case 'table':
if (self::$openPs) {
if (self::$openLinks) {
$sRet.= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
$sRet .= '';
self::$openPs = false;
} else {
if (self::$openTable > 1) {
//This is to fix a Word bug that does not allow to close a table and write just after a
$sRet .= '';
} else {
$sRet .= '';
}
}
self::$openTable--;
break;
case 'tr':
//Before closing a row we should make sure that there are no lacking cells due to a previous rowspan
$row = count(self::$tableGrid[self::$openTable]) - 1;
$column = count(self::$tableGrid[self::$openTable][$row]);
$sRet .= $this->closeTr($row, $column);
if (strpos(self::$WordML, '##') !== false) {
self::$WordML = str_replace('##', str_repeat('', $column), self::$WordML);
}
//We now may close the tr tag
$sRet .= '';
break;
case 'td':
case 'th':
if (self::$openPs) {
if (self::$openLinks) {
$sRet.= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
$sRet .= '';
self::$openPs = false;
} else {
$sRet .= '';
}
break;
case 'a':
if (self::$openLinks) {
$sRet.= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
break;
case 'sub':
case 'sup':
self::$openScript = '';
break;
case '#text':
if ($currentTag == 'close' && !self::$openSelect && !self::$openTextArea) {
if (self::$openLinks) {
$sRet.= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
$sRet .= '';
self::$openPs = false;
}
break;
case 'select':
self::$openSelect = false;
$dropdownId = uniqid(true);
$bookmarkId = rand(99999,99999999);
//Now we have to write the whole wordML
$sRet .= '';
foreach(self::$selectOptions as $key=>$value){
$sRet .= '';
}
$sRet .= ' FORMDROPDOWN ';
if ($currentTag == 'close' && self::$openPs) {
$sRet .= '';
self::$openPs = false;
}
break;
case 'option':
self::$openSelect = false;
break;
case 'textarea':
self::$openTextArea = false;
$bookmarkId = rand(99999,9999999);
$uniqueName = uniqid(true);
$sRet .= ' FORMTEXT ';
if(self::$textArea !=''){
$sRet .= self::$textArea;
}else{
if(isset($nodo['attributes']['size']) && $nodo['attributes']['size'] > 0){
$size = $nodo['attributes']['size'];
}else{
$size = 18;
}
for($k =0; $k <= $size; $k++){
$sRet .= ' '; //blank characters for Word
}
}
$sRet .= ' ';
if ($currentTag == 'close' && self::$openPs) {
$sRet .= '';
self::$openPs = false;
}
break;
default:
if ($currentTag == 'close') {
if (self::$openLinks) {
$sRet.= '';
self::$openLinks = false;
}
if (self::$openBookmark > 0) {
$sRet.= '';
self::$openBookmark = 0;
}
if (self::$openPs) {
$sRet .= '';
if(self::$openBr){
$sRet .= '';
self::$openBr = false;
}
self::$openPs = false;
}
}
}
}
return($sRet);
}
/**
* This function returns the default style for paragraphs inside a list
*
* @access private
* @return string
*/
private function listStyle() {
return 'ListParagraphPHPDOCX';
}
/**
* This function returns the default types of lists
*
* @access private
* @param array $tipo
* @return string
*/
private function listType($tipo = array(1, 2)) {
$counter = count(self::$openTags);
for ($j = $counter; $j >= ($this->_level - 1); $j--) {
if (@self::$openTags[$j] == 'ul') {
$num = $tipo[0];
break;
} else if (@self::$openTags[$j] == 'ol') {
$num = $tipo[1];
break;
}
}
if (isset($num)) {
return $num;
} else {
return $tipo[0];
}
}
/**
* This function returns the WordML formatting for a paragraph
* Support:
* w:pStyle,
* w:keepNext (page-break-after="avoid"),
* w:keepLines (page-break-inside="avoid"),
* w:pageBreakBefore (page-break-before="always"),
* w:widowControl (page-break-before="avoid"),
* w:pBdr (border-[top|left|bottom|right]-style!="none")(border-[top|left|bottom|right]-color)(border-[top|left|bottom|right]-width)(border!="none"),
* w:shd (background-color)(background),
* w:bidi (attribute dir="rtl"),
* w:spacing ([margin|padding]-top)([margin|padding]-bottom)(font-size)(line-height),
* w:ind ([margin|padding]-left)([margin|padding]-right)(font-size)(text-indent),
* w:jc (text-align),
* w:textDirection (attribute dir="rtl"),
* w:textAlignment (vertical-align!="baseline")(font-size),
* w:outlineLvl
*
* @access private
* @param array $properties
* @param array $level
* @return string
*/
private function generatePPr($properties, $level = '', $attributes = array(), $nodeName = false) {
$stringPPr = '';
$sTempStyle = $this->generateWordStyle($nodeName, $attributes);
if($sTempStyle) {
$stringPPr .= '';
}
if(!$this->strictWordStyles){
if(isset($properties['page_break_after']) && $properties['page_break_after'] == 'avoid'){
$stringPPr .= '';
}
if(isset($properties['page_break_inside']) && $properties['page_break_inside'] == 'avoid'){
$stringPPr .= '';
}
if(isset($properties['page_break_before']) && $properties['page_break_before'] == 'always'){
$stringPPr .= '';
}
if( isset($properties['float']) && ($properties['float'] == 'left' || $properties['float'] == 'right') && $this->parseFloats ) {
$distance = array();
foreach (self::$borders as $key => $value) {
$distance[$value] = $this->imageMargins($properties['margin_'.$value], $properties['padding_'.$value], $properties['font_size']);
}
$stringPPr .= '';
}
if(isset($properties['page_break_before']) && $properties['page_break_before'] == 'avoid'){
$stringPPr .= '';
}else{
$stringPPr .= '';
}
$stringPPr .= '';
foreach (self::$borders as $key => $value) {
if (isset($properties['border_' . $value . '_style']) && $properties['border_' . $value . '_style'] != 'none') {
$stringPPr .= '';
}
}
$stringPPr .= '';
if (isset($properties['background_color']) && is_array($properties['background_color'])) {
$color = $properties['background_color'];
$color = $this->wordMLColor($color);
$stringPPr .='';
}
//w:wordWrap //css3
if( isset($attributes['dir']) && strtolower($attributes['dir']) == 'rtl' ) {
$stringPPr .= '';
}
$stringPPr .= $this->pPrSpacing($properties);
$stringPPr .= $this->pPrIndent($properties);
if (isset($properties['text_align'])) {
$textAlign = self::$text_align[$properties['text_align']];
if (empty($textAlign)){
$textAlign = 'left';
}
$stringPPr .= '';
}
if( isset($attributes['dir']) && strtolower($attributes['dir']) == 'rtl' ) {
/*wordML
lrTb Left to Right, Top to Bottom
tbRl Top to Bottom, Right to Left
btLr Bottom to Top, Left to Right
lrTbV Left to Right, Top to Bottom Rotated
tbRlV Top to Bottom, Right to Left Rotated
tbLrV Top to Bottom, Left to Right Rotated*/
$stringPPr .= '';
}
if (isset($properties['vertical_align']) && $properties['vertical_align'] != 'baseline') {
$stringPPr .='';
}
if (is_numeric($level)) {
$stringPPr .= $this->setHeading($level);
}
}
$stringPPr .= '';
return $stringPPr;
}
/**
* This function returns the WordML formatting for a run of text
* Support:
* w:rFonts (font-family!="serif"),
* w:b (font-weight="[bold|bolder]"),
* w:i (font-style=["italic|oblique"),
* w:caps (text-transform="uppercase"),
* w:smallCaps (font-variant="small-caps"),
* w:strike (text-decoration="line-through"),
* w:color (color),
* w:position (vertical-align!="baseline")(font-size),
* w:sz (font-size),
* w:u (text-decoration="underline")
*
* @access private
* @param array $properties
* @return string
*/
private function generateRPr($properties) {
$stringRPr = '';
if(!$this->strictWordStyles){
if (isset($properties['font_family']) && $properties['font_family'] != 'serif') {
$arrayCSSFonts = explode(',', $properties['font_family']);
$font = trim($arrayCSSFonts[0]);
$font = str_replace('"', '', $font);
$stringRPr .= ' ';
}
//By the time being we only parse the color and if the font is bold or italic
if (@$properties['font_weight'] == 'bold' || @$properties['font_weight'] == 'bolder') {
$stringRPr .='';
}
if (@$properties['font_style'] == 'italic' || @$properties['font_style'] == 'oblique') {
$stringRPr .='';
}
if (isset($properties['text_transform']) && $properties['text_transform'] == 'uppercase') {
$stringRPr .='';
}
if (isset($properties['font_variant']) && $properties['font_variant'] == 'small-caps') {
$stringRPr .='';
}
if (isset($properties['text_decoration']) && $properties['text_decoration'] == 'line-through') {
$stringRPr .='';
}
if (@$properties['color'] != '' && is_array($properties['color'])) {
$color = $properties['color'];
$color = $this->wordMLColor($color);
$stringRPr .='';
}
if (isset($properties['vertical_align']) && $properties['vertical_align'] != 'baseline') {
$stringRPr .='';
}
if (@$properties['font_size'] != '') {
$stringRPr .='';
$stringRPr .='';
}
if (isset($properties['background_color']) && is_array($properties['background_color'])) {
$color = $this->wordMLNamedColor($properties['background_color']);
$stringRPr .='';
}
if ((self::$openLinks && @$properties['text_decoration'] != 'none')|| @$properties['text_decoration'] == 'underline') {
$stringRPr .='';
}
//w:bdr
if (@$properties['background_color'] != '' && is_array($properties['background_color'])) {
$color = $properties['background_color'];
$color = $this->wordMLColor($color);
$stringRPr .='';
}
if (self::$openScript != ''){
$stringRPr .='';
}
//w:rtl
//w:em //text-emphasis (css 3)
//w:oMath
}
$stringRPr .= '';
return $stringRPr;
}
/**
* This function returns the WordML formatting for a table
* Support:
* w:tblStyle (border),
* w:bidiVisual (attribute dir="rtl"),
* w:tblW (width),
* w:jc (attribute align),
* w:tblCellSpacing ([attribute cellspacing|border-spacing]),
* w:tblInd (text-indent),
* w:tblBorders (border_width)(border-[top|left|bottom|right]-style)(border-[top|left|bottom|right]-color)(border-[top|left|bottom|right]-width),
* w:shd (background)(background-color),
*
* @access private
* @param array $properties
* @param integer $border
* @return string
*/
private function generateTblPr($properties, $attributes) {
$stringTblPr = '';
$sTempStyle = $this->generateWordStyle('table', $attributes);
if (empty($sTempStyle)) {
if (isset($attributes['border']) && ((int) $attributes['border']) >= 1) {
$stringTblPr .= '';
} else {
$stringTblPr .= '';
}
}
else {
$stringTblPr .= '';
}
if(!$this->strictWordStyles){
if( isset($properties['float']) && ($properties['float'] == 'left' || $properties['float'] == 'right') && $this->parseFloats ) {
$distance = array();
foreach (self::$borders as $key => $value) {
$distance[$value] = $this->imageMargins($properties['margin_'.$value], $properties['padding_'.$value], $properties['font_size']);
}
$stringTblPr .= '';
}
if( isset($attributes['dir']) && strtolower($attributes['dir']) == 'rtl' ) {
$stringTblPr .= '';
}
//TODO OpenOffice needs $tableWidth > 0; else paints a table with double page width; don't work
if(!empty($properties['width'])) {
list($tableWidth, $tableWidthType) = $this->_wordMLUnits($properties['width']);
$stringTblPr .= '';
}
if(!empty($attributes['align'])){
$stringTblPr .= '';
}
if((!empty($attributes['cellspacing']) || !empty($properties['border_spacing'])) && isset($properties['border_collapse']) && $properties['border_collapse'] != 'collapse'){
$temp = trim(empty($properties['border_spacing'])?(empty($attributes['cellspacing'])?0:$attributes['cellspacing']):$properties['border_spacing']);
//border_spacing -> 1 or 2 values (horizontal, vertical); using only first (horizontal) //TODO calculate media (border_spacing="30px 10%")
if(strpos($temp, ' ') !== false) $temp = substr($temp, 0, strpos($temp, ' '));
$temp = $this->_wordMLUnits($temp);
$stringTblPr .= '';
}
if( isset($properties['text_indent']) ) {
$temp = $this->_wordMLUnits($properties['text_indent']);
$stringTblPr .= '';
}
if ($this->tableStyle == '') {
if(!empty($properties['border_width'])){
$stringTblPr .= '';
foreach (self::$borders as $key => $value) {
if (isset($properties['border_' . $value . '_style']) && $properties['border_' . $value . '_style'] != 'none') {
$stringTblPr .= '';
}
}
$stringTblPr .= '';
}
if (isset($properties['background_color']) && is_array($properties['background_color'])) {
$color = $properties['background_color'];
$color = $this->wordMLColor($color);
$stringTblPr .='';
} else if (isset(self::$rowColor) && is_array(self::$rowColor)) {
$color = self::$rowColor;
$color = $this->wordMLColor($color);
$stringTblPr .='';
}
}
//w:tblLayout
//w:tblCellMar
}
$stringTblPr .= '';
$stringTblPr .= '##';
return $stringTblPr;
}
/**
* This function returns the WordML formatting for a table row
* Support:
* w:trHeight (height),
* w:tblHeader (display="table-header-group"),
* w:jc (text_align)
*
* @access private
* @param array $properties
* @return string
*/
private function generateTrPr($properties) {
$stringTrPr = '';
//w:gridBefore
//w:gridAfter
//w:wBefore
//w:wAfter
//w:cantSplit
if(!$this->strictWordStyles){
if(!empty($properties['height'])){
$temp = $this->_wordMLUnits($properties['height']);
$stringTrPr .= '';
}
if ( isset($properties['display']) && $properties['display'] == 'table-header-group') {
$stringTrPr .='';
}
//w:tblCellSpacing
if (isset($properties['text_align'])) {
$textAlign = self::$text_align[$properties['text_align']];
if (empty($textAlign)){
$textAlign = 'left';
}
$stringTrPr .= '';
}
}
$stringTrPr .= '';
return $stringTrPr;
}
/**
* This function returns the WordML formatting for a table cell
* Support:
* w:tcW (width),
* w:gridSpan (attribute colspan),
* w:vMerge (attribute rowspan),
* w:tcBorders (border-[top|left|bottom|right]-style!="none")(border-[top|left|bottom|right]-color)(border-[top|left|bottom|right]-width)(border),
* w:shd (background-color)(background),
* w:vAlign (vertical-align)
*
* @access private
* @param array $properties
* @param integer $colspan
* @param integer $rowspan
* @param boolean $firstRow
* @return string
*/
private function generateTcPr($properties, $colspan, $rowspan, $firstRow) {
$stringTcPr = '';
if(@$properties['width'] != '') {
list($cellWidth, $cellWidthType) = $this->_wordMLUnits($properties['width']);
if ($cellWidth != 0 || $cellWidth != '') {
$stringTcPr .= '';
}
}
if ($colspan > 1) {
$stringTcPr .= '';
}
//w:hMerge
if ($rowspan > 1) {
$stringTcPr .= '';
}
if(!$this->strictWordStyles){
if ($this->tableStyle == '') {
$sTemp = '';
foreach (self::$borders as $key => $value) {
if (!empty($properties['border_' . $value . '_width']) && @$properties['border_' . $value . '_style'] != 'none') {
$sTemp .= '';
}
}
if(!empty($sTemp)) $stringTcPr .= ''.$sTemp.'';
if (isset($properties['background_color']) && is_array($properties['background_color'])) {
$color = $properties['background_color'];
$color = $this->wordMLColor($color);
$stringTcPr .='';
} else if (isset(self::$rowColor) && is_array(self::$rowColor)) {
$color = self::$rowColor;
$color = $this->wordMLColor($color);
$stringTcPr .='';
}
}
//w:noWrap
$stringTcPr .= $this->tcPrSpacing($properties);
//w:textDirection
//w:tcFitText
if (isset($properties['vertical_align']) && $properties['vertical_align'] != 'baseline') {
$stringTcPr .= '';
}
}
$stringTcPr .= '';
return $stringTcPr;
}
/**
* This function returns the WordML formatting for a list
* Support:
* w:pStyle,
* w:numPr (tag [ol|ul]),
* w:shd (background-color)(background),
* w:spacing ([margin|padding]-top)([margin|padding]-bottom)(font-size)(line-height),
* w:contextualSpacing,
* w:jc (text-align)
*
* @todo openoffice don't change bullets size
* @access private
* @param array $properties
* @return string
*/
private function generateListPr($properties) {
$stringListPr = '';
if(isset($properties['list_style_type']) && $properties['list_style_type'] == 'none'){
//We do not include numberings
}else{
$stringListPr .= '';
$stringListPr .= '';
}
if(!$this->strictWordStyles){
if (isset($properties['background_color']) && is_array($properties['background_color'])) {
$color = $properties['background_color'];
$color = $this->wordMLColor($color);
$stringListPr .='';
}
$stringListPr .= $this->pPrSpacing($properties);
if(isset($properties['list_style_type']) && $properties['list_style_type'] == 'none'){
$stringListPr .= $this->pPrIndent($properties);
}
$stringListPr .= '';
if (isset($properties['text_align'])) {
$textAlign = self::$text_align[$properties['text_align']];
if (empty($textAlign)){
$textAlign = 'left';
}
$stringListPr .= '';
}
if (isset($properties['font_size']) && $properties['font_size'] != '') {
$stringListPr .= '';
}
}
$stringListPr .= '';
return $stringListPr;
}
/**
* This function returns the applicable Word style if any
* wordStyles = array('#id|.class|' => 'style1', '#id|.class|' => 'style2', [...])
* @access private
* @param string $tag
* @param array $attributes
* @return string
*/
private function generateWordStyle($tag, $attributes) {
$sTempStyle = false;
if (!empty($this->wordStyles)) {
$attId = empty($attributes['id'])?'':$attributes['id'];
$attClass = empty($attributes['class'])?array():$attributes['class'];
$attTag = $tag;
//First we check if there is a Word Style for the tag
if(!empty($this->wordStyles['<'.$attTag.'>'])){
$sTempStyle = $this->wordStyles['<'.$attTag.'>'];
}
//Now we check for the classes
foreach($attClass as $key => $value){
if(!empty($this->wordStyles['.'.$value])){
$sTempStyle = $this->wordStyles['.'.$value];
}
}
//And now for the id
if(!empty($this->wordStyles['#'.$attId])){
$sTempStyle = $this->wordStyles['#'.$attId];
}
}
return $sTempStyle;
}
/**
* This function is used to take care of rowspans and colspans
*
* @access private
* @param integer $row
* @param integer $column
* @return integer
*/
private function countEmptyColumns($row, $column) {
if (isset(self::$tableGrid[self::$openTable][$row - 1][$column]) && self::$tableGrid[self::$openTable][$row - 1][$column][0] > 1) {
$merge = array(self::$tableGrid[self::$openTable][$row - 1][$column][0], self::$tableGrid[self::$openTable][$row - 1][$column][1]);
if ($merge[0] > 1) {
self::$WordML .= '';
for ($k = 0; $k < $merge[1]; $k++) {
array_push(self::$tableGrid[self::$openTable][count(self::$tableGrid[self::$openTable]) - 1], array(self::$tableGrid[self::$openTable][$row - 1][$column][0] - 1, $merge[1] - $k));
}
}
$this->countEmptyColumns($row, $column + $merge[1]);
}
}
/**
* This function is used to make sure that all table rows have the same grid
*
* @access private
* @param integer $row
* @param integer $column
* @return integer
*/
private function closeTr($row, $column, $colString=''){
if (isset(self::$tableGrid[self::$openTable][$row - 1][$column]) && self::$tableGrid[self::$openTable][$row - 1][$column][0] > 1) {
$merge = array(self::$tableGrid[self::$openTable][$row - 1][$column][0], self::$tableGrid[self::$openTable][$row - 1][$column][1]);
if ($merge[0] > 1) {
$colString .= '';
for ($k = 0; $k < $merge[1]; $k++) {
array_push(self::$tableGrid[self::$openTable][count(self::$tableGrid[self::$openTable]) - 1], array(self::$tableGrid[self::$openTable][$row - 1][$column][0] - 1, $merge[1] - $k));
}
}
$colString = $this->closeTr($row, $column + $merge[1], $colString);
}
return $colString;
}
/**
* This function is used to make sure that the url has the desired format
*
* @access private
* @param string $url
* @return string
*/
private function parseURL($url) {
$urlParts = explode('//', $url);
if ($urlParts[0] == 'http:' || $urlParts[0] == 'https:' || $urlParts[0] == 'file:') {
return $url;
}else if(($urlParts[0] == '' && count($urlParts) > 0 )){
return 'http:'.$url;
}else {
if ($url[0] == '/') {
$url = substr($url, 1);
}
}
return $this->baseURL . $url;
}
/**
* This function is used to determine the spacing before and after a paragraph
*
* @access private
* @return string
*/
private function pPrSpacing($properties) {
$before = 0;
$after = 0;
$line = 240;
//let us look at the margin top
if(!empty($properties['margin_top'])){
$temp = $this->_wordMLUnits($properties['margin_top'], $properties['font_size']);
$before += (int) round($temp[0]);
}
//let us look now at the padding top
if(!empty($properties['padding_top'])){
$temp = $this->_wordMLUnits($properties['padding_top'], $properties['font_size']);
$before += (int) round($temp[0]);
}
//let us look at the margin bottom
if(!empty($properties['margin_bottom'])){
$temp = $this->_wordMLUnits($properties['margin_bottom'], $properties['font_size']);
$after += (int) round($temp[0]);
}
//let us look now at the padding bottom
if(!empty($properties['padding_bottom'])){
$temp = $this->_wordMLUnits($properties['padding_bottom'], $properties['font_size']);
$after += (int) round($temp[0]);
}
$before = max(0, $before);
$after = max(0, $after);
//we now check the line height property
if(isset($properties['line_height'])){
$line = (int) round($properties['line_height'] * 16.6667);
}
$spacing ='_wordMLUnits($properties['margin_top'], $properties['font_size']);
}
if(!empty($properties['padding_top'])){
$temp = $this->_wordMLUnits($properties['padding_top'], $properties['font_size']);
if($temp[0] > $top[0]) $top = $temp;
}
if(!empty($properties['margin_bottom'])){
$bottom = $this->_wordMLUnits($properties['margin_bottom'], $properties['font_size']);
}
//let us look now at the padding bottom
if(!empty($properties['padding_bottom'])){
$temp = $this->_wordMLUnits($properties['padding_bottom'], $properties['font_size']);
if($temp[0] > $bottom[0]) $bottom = $temp;
}
$spacing ='';
$spacing .= '';
//$spacing .= '';
$spacing .= '';
//$spacing .= '';
$spacing .= '';
return $spacing;
}
/**
* This function is used to determine the left and right indent of the paragraph
*
* @access private
* @return string
*/
private function pPrIndent($properties) {
$left = 0;
$right = 0;
$firstLineIndent = 0;
//let us look at the margin left
if(!empty($properties['margin_left'])){
$temp = $this->_wordMLUnits($properties['margin_left'], $properties['font_size']);
$left += (int) round($temp[0]);
}
//let us look now at the padding left
if(!empty($properties['padding_left'])){
$temp = $this->_wordMLUnits($properties['padding_left'], $properties['font_size']);
$left += (int) round($temp[0]);
}
//let us look at the margin right
if(!empty($properties['margin_right'])){
$temp = $this->_wordMLUnits($properties['margin_right'], $properties['font_size']);
$right += (int) round($temp[0]);
}
//let us look now at the padding right
if(!empty($properties['padding_right'])){
$temp = $this->_wordMLUnits($properties['padding_right'], $properties['font_size']);
$right += (int) round($temp[0]);
}
if(!empty($properties['text_indent'])){
$temp = $this->_wordMLUnits($properties['text_indent'], $properties['font_size']);
$firstLineIndent = (int) round($temp[0]);
}
$indent ='';
return $heading;
}
/**
* This function returns the width of a line in eigths of a point (the measure used in WordML)
*
* @access private
* @param integer $size
* @return integer
*/
private function wordMLLineWidth($size) {
return (int) round($size * 5 / 0.75);
}
/**
* This function returns the colour as is used by WordML
*
* @access private
* @param string $color
* @return string
*/
private function wordMLColor($color) {
return strtoupper(str_replace('#', '', $color["hex"]));
}
/**
* This function returns the colour name as is used by WordML in highlighted text
black Black Highlighting Color
blue Blue Highlighting Color
cyan Cyan Highlighting Color
green Green Highlighting Color
magenta Magenta Highlighting Color
red Red Highlighting Color
yellow Yellow Highlighting Color
white White Highlighting Color
darkBlue Dark Blue Highlighting Color
darkCyan Dark Cyan Highlighting Color
darkGreen Dark Green Highlighting Color
darkMagenta Dark Magenta Highlighting Color
darkRed Dark Red Highlighting Color
darkYellow Dark Yellow Highlighting Color
darkGray Dark Gray Highlighting Color
lightGray Light Gray Highlighting Color
none No Text Highlighting
*
* @access private
* @param string $color
* @return string
*/
private function wordMLNamedColor($color) {
$color = strtoupper(str_replace('#', '', $color["hex"]));
$wordMLColors = array('000000' => 'black', '0000ff' => 'blue', '00ffff' => 'cyan', '00ff00' => 'green', 'ff00ff' => 'magenta', 'ff0000' => 'red',
'ffff00' => 'yellow', 'ffffff' => 'white', '00008b' => 'darkBlue', '008b8b' => 'darkCyan', '006400' => 'darkGreen', '8b008b' => 'darkMagenta',
'8b0000' => 'darkRed', '808000' => 'darkYellow', 'a9a9a9' => 'darkGray', 'd3d3d3' => 'lightGray', '' => 'none');
if(isset($wordMLColors[$color])) return($wordMLColors[$color]); //exact color
//return closest color
$hex24 = 16777215;
$retCol = '000000';
$red_color = hexdec(substr($color, 0, 2));$green_color = hexdec(substr($color, 2, 4));$blue_color = hexdec(substr($color, 4));
foreach($wordMLColors as $key => $val){
$red = $red_color - hexdec(substr($key, 0, 2));
$green = $green_color - hexdec(substr($key, 2, 4));
$blue = $blue_color - hexdec(substr($key, 4));
$dist = $red * $red + $green * $green + $blue * $blue; //distance between colors
if($dist <= $hex24){
$hex24 = $dist;
$retCol = $key;
}
}
return $wordMLColors[$retCol];
//return strtoupper(str_replace('#', '', $color["hex"]));
}
/**
* This function returns the border style if it is correct CSS, else it returns nil
*
* @access private
* @param string $borderStyle
* @return string
*/
private function getBorderStyles($borderStyle){
if (!empty($borderStyle) && array_key_exists($borderStyle, self::$borderStyles)){
return self::$borderStyles[$borderStyle];
}else{
return 'nil';
}
}
/**
* This function returns the border style of an embeded image
*
* @access private
* @param int $borderWidth
* @param string $borderStyle
* @return string
*/
private function imageBorders($borderWidth, $borderStyle, $borderColor){
if($borderWidth == 0){
$borderXML = '';
}else{
$borderXML = '
';
}
return $borderXML;
}
/**
* This function returns the image dimensions
*
* @access private
* @param array $size
* @param array $attributes
* @return array
*/
private function getImageDimensions($size, $attributes){
$width = $size[0];
$height = $size[1];
if (isset($attributes['width']) && $attributes['width'] > 1) {
$cx = $attributes['width'] * 7200;
}else if (empty($attributes['width']) && isset($attributes['height']) && $attributes['height'] > 1){
$cx = (int) ceil($width * $attributes['height']/$height)*7200;
} else {
$cx = $width * 7200;
}
if (isset($attributes['height']) && $attributes['height'] > 1) {
$cy = $attributes['height'] * 7200;
}else if (empty($attributes['height']) && isset($attributes['width']) && $attributes['width'] > 1){
$cy = (int) ceil($height * $attributes['width']/$width)*7200;
} else {
$cy = $height * 7200;
}
return array($cx, $cy);
}
/**
* This function returns the margin for the image
*
* @access private
* @param string $margin
* @param string $padding
* @return string
*/
private function imageMargins($margin, $padding, $fontSize){
$distance = 0;
//let us look at the margin
if($margin != 0){
$temp = $this->_wordMLUnits($margin, $fontSize);
$distance += (int) round($temp[0]);
}
//let us look at the padding
if($padding != 0){
$temp = $this->_wordMLUnits($padding, $fontSize);
$distance += (int) round($temp[0]);
}
return (int) round($distance * 635 * 0.75);//we are multypling by the scaling factor between twips and emus. The factor of 0.75 is ours to keep the extra scaling ratio we use on images
}
/**
* This function repairs the problem of empty cells in a table
*
* @access private
* @return string
*/
private function repairWordML($data){
//This is to fix the problem with empty cells in a table (a Word bug)
$data = str_replace('', '', $data);
//We also clean extra line feeds generated by the parser after
tags that may give problems with the rendering of WordML
$data = preg_replace('/[\n\r]/', '', $data);
//can not put two tables together
$data = preg_replace('/<\/w:tbl>/i', '', $data);
return $data;
}
/**
* Translates HTML units to Word ML units
*
* @access private
* @param string $sHtmlUnit Units in HTML format
* @param string $fontSize Font size, if applicable
* @return array
*/
private function _wordMLUnits($sHtmlUnit, $fontSize = false){
if(!preg_match('/^(-?\d*\.?\d*)(%|em|pt|px)?$/i', trim($sHtmlUnit), $match))
return(array(0, 'dxa'));
$match[1] = (strpos($match[1], '.') === 0?'0':'').$match[1];
$match[2] = empty($match[2])?'':$match[2];
//if($match[2] != 'em' && $match[2] != 'px' && !empty($fontSize)) $match[2] = 'pt';
switch($match[2]){
case '%': //in WordML the precentage is given in fiftieths of a percent
$widthType = 'pct';
$width = 50 * $match[1];
break;
case 'em':
$widthType = 'dxa';
$width = 20 * $match[1] * $fontSize;
break;
case 'pt': //in WordML the width is given in twentieths of a point
$widthType = 'dxa';
$width = 20 * $match[1];
break;
case 'px': //a pixel is around 3/4 of a point
default: //if no unit we asume is given in pixels
$widthType = 'dxa';
$width = 15 * $match[1];
}
return(array($width, $widthType));
}
/**
* Vertical position
*
* @access private
* @param string $valign Vertical align
* @param string $fontSize Font size, if applicable
* @return array
*/
private function _rprPosition($valign, $font_size){
$measureUnit = substr($valign, -2);
$quantity = (int) substr($valign, 0, -2); //TODO: parse other posible non-numerical values like top.
if($valign == 'middle'){
$measureUnit = 'em';
$quantity = -0.5;
}
if($valign == 'super'){
$measureUnit = 'em';
$quantity = 0.75;
}
if($valign == 'sub'){
$measureUnit = 'em';
$quantity = -0.75;
}
if($measureUnit == 'em'){
$vertDisplacement = (int) round($quantity * 0.5 * $font_size);
}else if ($measureUnit == 'px'){
$vertDisplacement = (int) round($quantity * 0.5 * 0.75);
}else{
$vertDisplacement = (int) round($quantity * 0.5);
}
return($vertDisplacement);
}
/**
* Vertical align
*
* @access private
* @param string $valign Vertical align
* @return string
*/
private function _verticalAlign($valign = 'baseline'){
$temp = $valign;
switch($temp){
case 'super':
case 'top':
case 'text-top':
$temp = 'top';
break;
case 'middle':
$temp = 'center';
break;
case 'sub':
case 'baseline':
case 'bottom':
case 'text-bottom':
default:
$temp = 'bottom';
}
return($temp);
}
}