Subversion Repositories qbpwcf-lib(archive)

<?php

//require_once 'functions.php';
require_once 'class.odt.php';

/**
 * A Class representing the properties of a page.
 *
 * @author Issam RACHDI
 */
class PageStyle {

        private $pageWidth = '21cm';

        private $pageHeight = '29.70cm';

        /**
         * The DOMDocument representing the styles xml file
         * @access private
         * @var DOMDocument
         */
        private $styleDocument;
        /**
         * The name of the style
         * @access private
         * @var string
         */
        private $name;

        /**
         * The DOMElement representing the page layout properties
         * @access private
         * @var DOMElement
         */
        private $pageLayoutProperties;

        private $masterStyleElement;

        /**
         * The DOMElement representing the header properties
         * @access private
         * @var DOMElement
         */
        private $headerProperties;

        /**
         * The DOMElement representing the header properties
         * @access private
         * @var DOMElement
         */
        private $footerProperties;

        /**
         * The constructor initializes the properties, then creates a <style:style>
         * element representing this specific style, and add it to <office:styles>
         * element
         * @param DOMDocument $styleDoc
         * @param string $name
         */
        function __construct($name) {
                $this->styleDocument = ODT::getInstance()->getStyleDocument();
                $this->name = $name;
                $pageLayoutStyleElement = $this->styleDocument->createElement('style:page-layout');
                $this->pageLayoutProperties = $this->styleDocument->createElement('style:page-layout-properties');
                $this->headerProperties = $this->styleDocument->createElement('style:header-footer-properties');
                $this->footerProperties = $this->styleDocument->createElement('style:header-footer-properties');
                $headerStyle = $this->styleDocument->createElement('style:header-style');
                $headerStyle->appendChild($this->headerProperties);
                $footerStyle = $this->styleDocument->createElement('style:footer-style');
                $footerStyle->appendChild($this->footerProperties);
                $pageLayoutStyleElement->setAttribute('style:name', $name);
                $pageLayoutStyleElement->appendChild($this->pageLayoutProperties);
                $pageLayoutStyleElement->appendChild($headerStyle);
                $pageLayoutStyleElement->appendChild($footerStyle);
                $this->styleDocument->getElementsByTagName('office:automatic-styles')->item(0)->appendChild($pageLayoutStyleElement);
                $this->masterStyleElement = $this->styleDocument->createElement('style:master-page');
                $this->masterStyleElement->setAttribute('style:name', 'Standard');
                $this->masterStyleElement->setAttribute('style:page-layout-name', $name);
                $this->styleDocument->getElementsByTagName('office:master-styles')->item(0)->appendChild($this->masterStyleElement);
                $this->setHorizontalMargin('2cm', '2cm');
        }

        /**
         * return the name of this style
         * @return string
         */
        function getStyleName() {
                return $this->name;
        }

        /**
         * Specify the physical size of the page.
         *
         * @param integer|length $width
         * @param integer|string $height
         */
        function setPageSize($width, $height) {
                if (!isLengthValue($width) && !isLengthValue($height)) {
                        throw new StyleException('Invalid page-height value');
                }
                $this->pageWidth = $width;
                $this->pageHeight = $height;
                $this->pageLayoutProperties->setAttribute('fo:page-width', $width);
                $this->pageLayoutProperties->setAttribute('fo:page-height', $height);
        }

        /**
         * Sepcifies default number format for page styles, which is used to display page numbers within headers and footers.
         *
         * @param string $prefix
         * @param string $suffix
         * @param string $format Valid values: "1", "a", "A", "i", or "I"
         */
        function setPageNumberFormat($prefix, $suffix, $format) {
                $this->pageLayoutProperties->setAttribute('style:num-prefix', $prefix);
                $this->pageLayoutProperties->setAttribute('fo:page-suffix', $suffix);
                switch ($format) {
                        case '1':
                        case 'a':
                        case 'A':
                        case 'i':
                        case 'I':
                                $this->pageLayoutProperties->setAttribute('fo:page-suffix', $format);break;
                        default:
                                throw new StyleException('Invalid num-format value');
                }
        }

        /**
         * Specifies the orientation of the printed page
         *
         * @param integer $orientation Valid values: StyleConstants::(LANDSCAPE|PORTRAIT)
         */
        function setOrientation($orientation) {
                switch ($orientation) {
                        case StyleConstants::LANDSCAPE:
                                $orientation = 'landscape';
                                if ($this->pageWidth < $this->pageHeight) {
                                        $this->setPageSize($this->pageHeight, $this->pageWidth);
                                }
                                break;
                        case StyleConstants::PORTRAIT:
                                $orientation = 'portrait';
                                if ($this->pageWidth > $this->pageHeight) {
                                        $this->setPageSize($this->pageHeight, $this->pageWidth);
                                }
                                break;
                        default:
                                throw new StyleException('Invalid orientation value.');
                }
                $this->pageLayoutProperties->setAttribute('style:print-orientation', $orientation);
        }

        /**
         * Specify the left & right margin for the page
         *
         * @param integer|string $leftMargin
         * @param integer|string $rightMargin
         */
        function setHorizontalMargin($leftMargin = 0, $rightMargin = 0) {
                if (!isNumeric($leftMargin) && !isLengthValue($leftMargin)) {
                        throw new StyleException('Invalid left-margin value');
                }
                if (!isNumeric($rightMargin) && !isLengthValue($rightMargin)) {
                        throw new StyleException('Invalid right-margin value');
                }
                
                $this->pageLayoutProperties->setAttribute('fo:margin-left', $leftMargin);
                $this->pageLayoutProperties->setAttribute('fo:margin-right', $rightMargin);
        }

        /**
         * Specify the top & bottom margin for the page
         *
         * @param integer|string $topMargin
         * @param integer|string $bottomMargin
         */
        function setVerticalMargin($topMargin, $bottomMargin) {
                if (!isNumeric($topMargin, true) && !isLengthValue($topMargin, true)) {
                        throw new StyleException('Invalid top-margin value');
                }
                if (!isNumeric($bottomMargin) && !isLengthValue($bottomMargin)) {
                        throw new StyleException('Invalid bottom-margin value');
                }
                $this->pageLayoutProperties->setAttribute('fo:margin-top', $topMargin);
                $this->pageLayoutProperties->setAttribute('fo:margin-bottom', $bottomMargin);
        }

        /**
         * Specifies the border properties for the page.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         * @param string $position Do not use this, it's for internal use only.
         */
        function setBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN, $position = '') {
                if (!isColor($borderColor)) {
                        throw new StyleException('Invalid border-color value');
                }

                switch ($borderStyle) {
                        case StyleConstants::SOLID:
                                $borderStyle = 'solid';break;
                        case StyleConstants::DOUBLE:
                                $borderStyle = 'double';break;
                        default:
                                throw new StyleException('Invalid border-style value');
                }
                switch ($borderWidth) {
                        case StyleConstants::THIN:
                                $borderWidth = 'thin';break;
                        case StyleConstants::THICK:
                                $borderWidth = 'thick';break;
                        case StyleConstants::MEDIUM:
                                $borderWidth = 'medium';break;
                        default:
                                if (!isLengthValue($borderWidth, true)) {
                                        throw new StyleException('Invalid border-width value');
                                }
                }
                if (!empty($position)) {
                        if (!in_array($position, array('top', 'bottom', 'left', 'right'))) {
                                $position = '';
                        } else {
                                $position = '-'.$position;
                        }
                }
                $this->pageLayoutProperties->setAttribute('fo:border'.$position, "$borderWidth $borderStyle $borderColor");
        }

        /**
         * Specifies the top border property for pages.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */
        function setTopBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setBorder($borderColor, $borderStyle, $borderWidth, 'top');
        }

        /**
         * Specifies the bottom border property for paragraphs.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */
        function setBottomBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setBorder($borderColor, $borderStyle, $borderWidth, 'bottom');
        }

        /**
         * Specifies the left border property for pages.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */
        function setLeftBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setBorder($borderColor, $borderStyle, $borderWidth, 'left');
        }

        /**
         * Specifies the right border property for pages.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */
        function setRightBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setBorder($borderColor, $borderStyle, $borderWidth, 'right');
        }

        /**
         * Specifies the spacing around the page.
         * Note that you must first specify the border
         *
         * @param length $padding
         * @param string $position Do not use this, it's for internal use only.
         */
        function setPadding($padding, $position = '') {
                if (!isLengthValue($padding, true) && !isNumeric($padding)) {
                        throw new StyleException('Invalid padding value');
                }
                if (!empty($position)) {
                        if (!in_array($position, array('top', 'bottom', 'left', 'right'))) {
                                $position = '';
                        } else {
                                $position = '-'.$position;
                        }
                }
                $this->pageLayoutProperties->setAttribute('fo:padding'.$position, $padding);
        }

        /**
         * Specifies the spacing on top of the pages.
         *
         * @param length $padding
         */
        function setTopPadding($padding) {
                $this->setPadding($padding, 'top');
        }

        /**
         * Specifies the spacing in the bottom of the pages.
         *
         * @param length $padding
         */
        function setBottomPadding($padding) {
                $this->setPadding($padding, 'bottom');
        }

        /**
         * Specifies the spacing in the left side of the pages.
         *
         * @param length $padding
         */
        function setLeftPadding($padding) {
                $this->setPadding($padding, 'left');
        }

        /**
         * Specifies the spacing in the right side of the pages.
         *
         * @param length $padding
         */
        function setRightPadding($padding) {
                $this->setPadding($padding, 'right');
        }

        /**
         * Specifies the background color for the page
         *
         * @param color $color
         */
        function setBackgroundColor($color) {
                if ($color != StyleConstants::TRANSPARENT && !isColor($color)) {
                        throw new StyleException('Invalid page background color');
                }
                $this->pageLayoutProperties->setAttribute('fo:background-color', $color);
        }

        /**
         * Specifies the background image for the pages. Note that if you specify the position, the image
         * will not be repeated
         *
         * @param string $image The image's path.
         * @param integer $position Specifies where to position a background image in a paragraph.
         * Valid values are StyleConstants::(LEFT|RIGHT|CENTER|TOP|BOTTOM)
         */
        function setBackgroundImage($image, $repeat = StyleConstants::REPEAT,
                                                                $position = -1) {
                $file = fopen($image, 'r');
                if (!$file) {
                        throw new StyleException('Cannot open image');
                }
                switch($repeat) {
                        case StyleConstants::REPEAT:
                                $repeat = 'repeat';break;
                        case StyleConstants::NO_REPEAT:
                                $repeat = 'no-repeat';break;
                        case StyleConstants::STRETCH:
                                $repeat = 'stretch';break;
                        default:
                                throw new StyleException('Invalid repeat value');
                }
                switch($position) {
                        case -1:
                                break;
                        case StyleConstants::LEFT:
                                $position = 'left';break;
                        case StyleConstants::RIGHT:
                                $position = 'right';break;
                        case StyleConstants::CENTER:
                                $position = 'center';break;
                        case StyleConstants::TOP:
                                $position = 'top';break;
                        case StyleConstants::BOTTOM:
                                $position = 'left';break;
                        default:
                                throw new StyleException('Invalid background-position value');
                }
                $dataImg = fread($file, filesize($image));
                $dateImgB64 = base64_encode($dataImg);
                fclose($file);
                $binaryElement = $this->styleDocument->createElement('office:binary-data', $dateImgB64);
                $imageElement = $this->styleDocument->createElement('style:background-image');
                $imageElement->setAttribute('style:repeat', $repeat);
                if ($position != -1) {
                        $imageElement->setAttribute('style:position', $position);
                }
                $imageElement->appendChild($binaryElement);
                $this->pageLayoutProperties->appendChild($imageElement);
        }

        //style:columns


        /**
         * Specify the number of the first page
         *
         * @param integer $number
         */
        function setFirstPageNumber($number) {
                if (!isNumeric($number)) {
                        throw new StyleException('Invalid first page number value.');
                }
                $this->pageLayoutProperties->setAttribute('style:first-page-number', $number);
        }

        /**
         * Specifies the maximum amount of space on the page that a footnote can occupy.
         *
         * @param length $height
         */
        function setMaximumFootnoteHeight($height) {
                if (!isNumeric($height)) {
                        throw new StyleException('Invalid maximum footnote height.');
                }
                $this->pageLayoutProperties->setAttribute('style:footnote-max-height', $height);
        }

        /**
         * Specify the line that separates the footnote from the body text area on a page
         *
         * @param length $lineWidth
         * @param color $color
         * @param integer $adjustment How the line is aligned on the page. Valid values: StyleConstants::(LEFT|RIGHT|CENTER)
         * @param length $distanceBefore
         * @param length $distanceAfter
         * @param integer $lineStyle
         */

        function setFootnoteSeparator($lineWidth = '1mm', $color = '#000000', $adjustment = StyleConstants::CENTER,
                                                                  $distanceBefore = '5mm', $distanceAfter = '5mm',
                                                                  $lineStyle = StyleConstants::SOLID) {

                if (!isLengthValue($lineWidth)) {
                        throw new StyleException('Invalid line-width value');
                }
                if (!isColor($color)) {
                        throw new StyleException('Invalid color value');
                }
                switch ($adjustment) {
                        case StyleConstants::LEFT:
                                $adjustment = 'left';break;
                        case StyleConstants::RIGHT:
                                $adjustment = 'right';break;
                        case StyleConstants::CENTER:
                                $adjustment = 'center';break;
                        default:
                                throw new StyleException('Invalid adjustment value');
                }
                if (!isLengthValue($distanceBefore)) {
                        throw new StyleException('Invalid distance-before value');
                }
                if (!isLengthValue($distanceAfter)) {
                        throw new StyleException('Invalid distance-before value');
                }
                switch($lineStyle) {
                        case StyleConstants::NONE:
                                $lineStyle = 'none';break;
                        case StyleConstants::SOLID:
                                $lineStyle = 'solid';break;
                        case StyleConstants::DOTTED:
                                $lineStyle = 'dotted';break;
                        case StyleConstants::DASH:
                                $lineStyle = 'dash';break;
                        case StyleConstants::LONG_DASH:
                                $lineStyle = 'long-dash';break;
                        case StyleConstants::DOT_DOT_DASH:
                                $lineStyle = 'dot-dot-dash';break;
                        case StyleConstants::WAVE:
                                $lineStyle = 'wave';break;
                        default:
                                throw new StyleException('Invalid line-style value.');
                }
                $footNote = $this->styleDocument->createElement('style:footnote-sep');
                $footNote->setAttribute('style:width', $lineWidth);
                $footNote->setAttribute('style:color', $color);
                $footNote->setAttribute('style:adjustment', $adjustment);
                $footNote->setAttribute('style:distance-before-sep', $distanceBefore);
                $footNote->setAttribute('style:distance-after-sep', $distanceAfter);
                $footNote->setAttribute('style:line-style', $lineStyle);

        }

        /**
         * Specifies the writing mode for the pages.
         *
         * @param integer $writingMode Valid values: StyleConstants::(LR_TB|RL_TB|TB_RL|TB_LR|RL|TB|PAGE)
         */
        function setWritingMode($writingMode) {
                switch ($writingMode) {
                        case StyleConstants::LR_TB:
                                $writingMode = 'lr-tb';break;
                        case StyleConstants::RL_TB:
                                $writingMode = 'rl-tb';break;
                        case StyleConstants::TB_RL:
                                $writingMode = 'tb-rl';break;
                        case StyleConstants::TB_LR:
                                $writingMode = 'tb-lr';break;
                        case StyleConstants::RL:
                                $writingMode = 'rl';break;
                        case StyleConstants::TB:
                                $writingMode = 'tb';break;
                        case StyleConstants::PAGE:
                                $writingMode = 'page';break;
                        default:
                                throw new StyleException('Invalid writing-mode value');
                }
                $this->pageLayoutProperties->setAttribute('style:writing-mode', $writingMode);
        }

        /**
         * Specifies the height of the headers & footers
         *
         * @param length $height
         */
        function setHeadFootHeight($element, $height) {
                if (!isLengthValue($height)) {
                        throw new StyleException('Invalid height value.');
                }
                if ($element == 'header') {
                        $this->headerProperties->setAttribute('svg:height', $height);
                } else if ($element == 'footer') {
                        $this->footerProperties->setAttribute('svg:height', $height);
                }
        }

        function setHeaderHeight($height) {
                $this->setHeadFootHeight('header', $height);
        }
        function setFooterHeight($height) {
                $this->setHeadFootHeight('footer', $height);
        }

        /**
         * Specifies the minimum height of the headers & footers
         *
         * @param length $height
         */
        function setHeadFootMinHeight($element, $minHeight) {
                if (!isLengthValue($minHeight)) {
                        throw new StyleException('Invalid min-height value.');
                }
                if ($element == 'header') {
                        $this->headerProperties->setAttribute('fo:min-height', $minHeight);
                } else if ($element == 'footer'){
                        $this->footerProperties->setAttribute('fo:min-height', $minHeight);
                }
        }

        function setHeaderMinHeight($minHeight) {
                $this->setHeadFootMinHeight('header', $minHeight);
        }
        function setFooterMinHeight($minHeight) {
                $this->setHeadFootMinHeight('footer', $minHeight);
        }

        /**
         * Specify the left & right margin for headers & footers
         *
         * @param integer|string $leftMargin
         * @param integer|string $rightMargin
         */
        function setHeadFootHMargins($element, $leftMargin = 0, $rightMargin = 0) {
                if (!isNumeric($leftMargin) && !isLengthValue($leftMargin)) {
                        throw new StyleException('Invalid left-margin value');
                }
                if (!isNumeric($rightMargin) && !isLengthValue($rightMargin)) {
                        throw new StyleException('Invalid right-margin value');
                }
                if ($element == 'header') {
                        $this->headerProperties->setAttribute('fo:margin-left', $leftMargin);
                        $this->headerProperties->setAttribute('fo:margin-right', $rightMargin);
                } else if ($element == 'footer') {
                        $this->footerProperties->setAttribute('fo:margin-left', $leftMargin);
                        $this->footerProperties->setAttribute('fo:margin-right', $rightMargin);
                }
        }

        function setHeaderHMargins($leftMargin = 0, $rightMargin = 0) {
                $this->setHeadFootHMargins('header', $leftMargin, $rightMargin);
        }

        function setFooterHMargins($leftMargin = 0, $rightMargin = 0) {
                $this->setHeadFootHMargins('footer', $leftMargin, $rightMargin);
        }

        /**
         * Specify the top & bottom margin for headers & footers
         *
         * @param integer|string $topMargin
         * @param integer|string $bottomMargin
         */
        function setHeadFootVMargins($topMargin, $bottomMargin) {
                if (!isNumeric($topMargin, true) && !isLengthValue($topMargin, true)) {
                        throw new StyleException('Invalid top-margin value');
                }
                if (!isNumeric($bottomMargin) && !isLengthValue($bottomMargin)) {
                        throw new StyleException('Invalid bottom-margin value');
                }
                $this->headerFooterProperties->setAttribute('fo:margin-top', $topMargin);
                $this->headerFooterProperties->setAttribute('fo:margin-bottom', $bottomMargin);
        }

        function setHeaderVMargins($topMargin = 0, $bottomMargin = 0) {
                $this->setHeadFootHMargins('header', $topMargin, $bottomMargin);
        }

        function setFooterVMargins($topMargin = 0, $bottomMargin = 0) {
                $this->setHeadFootHMargins('footer', $topMargin, $bottomMargin);
        }

        /**
         * Specifies the border properties for headers & footers.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         * @param string $position Do not use this, it's for internal use only.
         */
        function setHeadFootBorder($element, $borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN, $position = '') {
                if (!isColor($borderColor)) {
                        throw new StyleException('Invalid border-color value');
                }

                switch ($borderStyle) {
                        case StyleConstants::SOLID:
                                $borderStyle = 'solid';break;
                        case StyleConstants::DOUBLE:
                                $borderStyle = 'double';break;
                        default:
                                throw new StyleException('Invalid border-style value');
                }
                switch ($borderWidth) {
                        case StyleConstants::THIN:
                                $borderWidth = 'thin';break;
                        case StyleConstants::THICK:
                                $borderWidth = 'thick';break;
                        case StyleConstants::MEDIUM:
                                $borderWidth = 'medium';break;
                        default:
                                if (!isLengthValue($borderWidth, true)) {
                                        throw new StyleException('Invalid border-width value');
                                }
                }
                if (!empty($position)) {
                        if (!in_array($position, array('top', 'bottom', 'left', 'right'))) {
                                $position = '';
                        } else {
                                $position = '-'.$position;
                        }
                }
                if ($element == 'header') {
                        $this->headerProperties->setAttribute('fo:border'.$position, "$borderWidth $borderStyle $borderColor");
                } else if ($element == 'footer') {
                        $this->footerProperties->setAttribute('fo:border'.$position, "$borderWidth $borderStyle $borderColor");
                }
        }

        function setHeaderBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                                         $borderWidth = StyleConstants::THIN) {
                $this->setHeadFootBorder('header', $borderColor, $borderStyle, $borderWidth);
        }
        function setFooterBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                                         $borderWidth = StyleConstants::THIN) {
                $this->setHeadFootBorder('footer', $borderColor, $borderStyle, $borderWidth);
        }

        /**
         * Specifies the border properties for headers & footers.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */

        function setHeaderTopBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setHeaderBorder($borderColor, $borderStyle, $borderWidth, 'top');
        }
        function setFooterTopBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                                                $borderWidth = StyleConstants::THIN) {
                $this->setFooterBorder($borderColor, $borderStyle, $borderWidth, 'top');
        }

        /**
         * Specifies the border properties for headers & footers.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */

        function setHeaderBottomBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setHeaderBorder($borderColor, $borderStyle, $borderWidth, 'bottom');
        }
        function setFooterBottomBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                                                $borderWidth = StyleConstants::THIN) {
                $this->setFooterBorder($borderColor, $borderStyle, $borderWidth, 'bottom');
        }

        /**
         * Specifies the border properties for headers & footers.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */

        function setHeaderLeftBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setHeaderBorder($borderColor, $borderStyle, $borderWidth, 'left');
        }
        function setFooterLeftBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                                                $borderWidth = StyleConstants::THIN) {
                $this->setFooterBorder($borderColor, $borderStyle, $borderWidth, 'left');
        }

        /**
         * Specifies the border properties for headers & footers.
         *
         * @param color $borderColor Border color
         * @param int $borderStyle Valid values: StyleConstants::(SOLID|DOUBLE)
         * @param int|length $borderWidth Can be a length, or one of these values: StyleConstants::(THIN|THICK|MEDIUM)
         */

        function setHeaderRightBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                           $borderWidth = StyleConstants::THIN) {
                $this->setHeaderBorder($borderColor, $borderStyle, $borderWidth, 'right');
        }
        function setFooterRightBorder($borderColor = '#000000', $borderStyle = StyleConstants::SOLID,
                                                                $borderWidth = StyleConstants::THIN) {
                $this->setFooterBorder($borderColor, $borderStyle, $borderWidth, 'right');
        }

        /**
         * Specifies the spacing around the headers & footers..
         * Note that you must first specify the border for the padding to work
         *
         * @param length $padding
         * @param string $position Do not use this, it's for internal use only.
         */
        function setHeadFootPadding($element, $padding, $position = '') {
                if (!isLengthValue($padding, true) && !isNumeric($padding)) {
                        throw new StyleException('Invalid padding value');
                }
                if (!empty($position)) {
                        if (!in_array($position, array('top', 'bottom', 'left', 'right'))) {
                                $position = '';
                        } else {
                                $position = '-'.$position;
                        }
                }
                if ($element == 'header') {
                        $this->headerProperties->setAttribute('fo:padding'.$position, $padding);
                } else if ($element == 'footer') {
                        $this->footerProperties->setAttribute('fo:padding'.$position, $padding);
                }
        }

        function setHeaderPadding($padding, $position = '') {
                $this->setHeadFootPadding('header', $padding, $position);
        }
        function setFooterPadding($padding, $position = '') {
                $this->setHeadFootPadding('footer', $padding, $position);
        }

        function setHeaderTopPadding($padding) {
                $this->setHeaderPadding($padding, 'top');
        }
        function setFooterTopPadding($padding) {
                $this->setFooterPadding($padding, 'top');
        }

        function setHeaderBottomPadding($padding) {
                $this->setHeaderPadding($padding, 'bottom');
        }
        function setFooterBottomPadding($padding) {
                $this->setFooterPadding($padding, 'bottom');
        }

        function setHeaderLeftPadding($padding) {
                $this->setHeaderPadding($padding, 'left');
        }
        function setFooterLeftPadding($padding) {
                $this->setFooterPadding($padding, 'left');
        }

        function setHeaderRightPadding($padding) {
                $this->setHeaderPadding($padding, 'right');
        }
        function setFooterRightPadding($padding) {
                $this->setFooterPadding($padding, 'right');
        }

        /**
         * Specify the background color of the headers & footers.
         *
         * @param color $color
         */
        function setHeadFootBackgroundColor($element, $color) {
                if ($color != StyleConstants::TRANSPARENT && !isColor($color)) {
                        throw new StyleException('Invalid background color');
                }
                if ($element == 'header') {
                        $this->headerProperties->setAttribute('fo:background-color', $color);
                } else if ($element == 'footer') {
                        $this->footerProperties->setAttribute('fo:background-color', $color);
                }
        }

        function setHeaderBackground($color) {
                $this->setHeadFootBackgroundColor('header', $color);
        }
        function setFooterBackground($color) {
                $this->setHeadFootBackgroundColor('footer', $color);
        }

        /**
         *
         * @param string $image The image's path.
         * @param integer $repeat Specifies whether a background image is repeated or stretched.
         * Valid values are StyleConstants::(REPEAT|NO_REPEAT|STRETCH)
         * @param integer $position Specifies where to position a background image in a paragraph.
         * Valid values are StyleConstants::(LEFT|RIGHT|CENTER|TOP|BOTTOM)
         */
        function setHeadFootBackgroundImage($element, $image, $repeat = StyleConstants::REPEAT,
                                                                $position = StyleConstants::CENTER) {
                $file = fopen($image, 'r');
                if (!$file) {
                        throw new StyleException('Cannot open image');
                }
                switch($repeat) {
                        case StyleConstants::REPEAT:
                                $repeat = 'repeat';break;
                        case StyleConstants::NO_REPEAT:
                                $repeat = 'no-repeat';break;
                        case StyleConstants::STRETCH:
                                $repeat = 'stretch';break;
                        default:
                                throw new StyleException('Invalid repeat value');
                }
                switch($position) {
                        case StyleConstants::LEFT:
                                $position = 'left';break;
                        case StyleConstants::RIGHT:
                                $position = 'right';break;
                        case StyleConstants::CENTER:
                                $position = 'center';break;
                        case StyleConstants::TOP:
                                $position = 'top';break;
                        case StyleConstants::BOTTOM:
                                $position = 'left';break;
                        default:
                                throw new StyleException('Invalid background-position value');
                }
                $dataImg = fread($file, filesize($image));
                $dateImgB64 = base64_encode($dataImg);
                fclose($file);
                $binaryElement = $this->styleDocument->createElement('office:binary-data', $dateImgB64);
                $imageElement = $this->styleDocument->createElement('style:background-image');
                $imageElement->setAttribute('style:repeat', $repeat);
                $imageElement->setAttribute('style:position', $position);
                $imageElement->appendChild($binaryElement);
                if ($element == 'header') {
                        $this->headerProperties->appendChild($imageElement);
                } else if ($element == 'footer') {
                        $this->footerProperties->appendChild($imageElement);
                }
        }

        function setHeaderBackgroundImage($image, $repeat = StyleConstants::REPEAT, $position = StyleConstants::CENTER) {
                $this->setHeadFootBackgroundColor('header', $image, $repeat, $position);
        }
        function setFooterBackgroundImage($image, $repeat = StyleConstants::REPEAT, $position = StyleConstants::CENTER) {
                $this->setHeadFootBackgroundColor('footer', $image, $repeat, $position);
        }

        function setHeadFootContent($element, $content, $paragraphStyles = null) {
                $p = new Paragraph($paragraphStyles, false);
                if ($content == StyleConstants::PAGE_NUMBER) {
                        $pageNumber = ODT::getInstance()->getDocumentContent()->createElement('text:page-number');
                        $pageNumber->setAttribute('text:select-page', 'current');
                        $p->getDOMElement()->appendChild($pageNumber);
                } else if($content == StyleConstants::CURRENT_DATE) {
                        $date = ODT::getInstance()->getDocumentContent()->createElement('text:date');
                        $p->getDOMElement()->appendChild($date);
                } else {
                        $p->addText($content);
                }
                $headfoot = $this->styleDocument->createElement($element);
                $headfoot->appendChild($this->styleDocument->importNode($p->getDOMElement(), true));
                $this->masterStyleElement->appendChild($headfoot);
        }

        function setHeaderContent($content, $paragraphStyles = null) {
                $this->setHeadFootContent('style:header', $content, $paragraphStyles);
        }

        function setFooterContent($content, $paragraphStyles = null) {
                $this->setHeadFootContent('style:footer', $content, $paragraphStyles);
        }
}
?>