WebSVN – eFlore/Applications.cel – Diff – /trunk/jrest/lib/Spreadsheet/Excel/Writer/Worksheet.php

 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
-require_once('Parser.php');
+require_once 'Spreadsheet/Excel/Writer/Parser.php';
-require_once('BIFFwriter.php');
+require_once 'Spreadsheet/Excel/Writer/BIFFwriter.php';
 /**
 * Class for generating Excel Spreadsheets
     var $_xls_strmax;
     /**
     * First row for the DIMENSIONS record
     * @var integer
-    * @see storeDimensions()
+    * @see _storeDimensions()
     */
     var $_dim_rowmin;
     /**
     * Last row for the DIMENSIONS record
     * @var integer
-    * @see storeDimensions()
+    * @see _storeDimensions()
     */
     var $_dim_rowmax;
     /**
     * First column for the DIMENSIONS record
     * @var integer
-    * @see storeDimensions()
+    * @see _storeDimensions()
     */
     var $_dim_colmin;
     /**
     * Last column for the DIMENSIONS record
     * @var integer
-    * @see storeDimensions()
+    * @see _storeDimensions()
     * @var integer
     */
     var $print_colmax;
+    /**
+    * Whether to display RightToLeft.
+    * @var integer
+    */
+    var $_Arabic;
+    /**
+    * Whether to use outline.
+    * @var integer
+    */
+    var $_outline_on;
+    /**
+    * Auto outline styles.
+    * @var bool
+    */
+    var $_outline_style;
+    /**
+    * Whether to have outline summary below.
+    * @var bool
+    */
+    var $_outline_below;
+    /**
+    * Whether to have outline summary at the right.
+    * @var bool
+    */
+    var $_outline_right;
+    /**
+    * Outline row level.
+    * @var integer
+    */
+    var $_outline_row_level;
+    /**
+    * Whether to fit to page when printing or not.
+    * @var bool
+    */
+    var $_fit_page;
+    /**
+    * Number of pages to fit wide
+    * @var integer
+    */
+    var $_fit_width;
+    /**
+    * Number of pages to fit high
+    * @var integer
+    */
+    var $_fit_height;
+    /**
+    * Reference to the total number of strings in the workbook
+    * @var integer
+    */
+    var $_str_total;
+    /**
+    * Reference to the number of unique strings in the workbook
+    * @var integer
+    */
+    var $_str_unique;
+    /**
+    * Reference to the array containing all the unique strings in the workbook
+    * @var array
+    */
+    var $_str_table;
+    /**
+     * Number of merged cell ranges in actual record
+     * @var int $_merged_cells_counter
+     */
+    var $_merged_cells_counter = 0;
+    /**
+     * Number of actual mergedcells record
+     * @var int $_merged_cells_record
+     */
+    var $_merged_cells_record = 0;
+    /**
+    * Merged cell ranges
+    * @var array
+    */
+    var $_merged_ranges;
+    /**
+    * Charset encoding currently used when calling writeString()
+    * @var string
+    */
+    var $_input_encoding;
     /**
     * Constructor
+    *
     * @param string  $name         The name of the new worksheet
     * @param integer $index        The index of the new worksheet
     * @param mixed   &$activesheet The current activesheet of the workbook we belong to
     * @param mixed   &$firstsheet  The first worksheet in the workbook we belong to
     * @param mixed   &$url_format  The default format for hyperlinks
+    * @param mixed   &$parser      The formula parser created for the Workbook
+    * @param string  $tmp_dir      The path to the directory for temporary files
-    * @param mixed   &$parser      The formula parser created for the Workbook
+    * @access private
     */
+    function Spreadsheet_Excel_Writer_Worksheet($BIFF_version, $name,
-    function Spreadsheet_Excel_Writer_Worksheet($name, $index, &$activesheet,
+                                                $index, &$activesheet,
+                                                &$firstsheet, &$str_total,
+                                                &$str_unique, &$str_table,
-                                                &$firstsheet, &$url_format,
+                                                &$url_format, &$parser,
-                                                &$parser)
+                                                $tmp_dir)
+    {
         // It needs to call its parent's constructor explicitly
+        $this->Spreadsheet_Excel_Writer_BIFFwriter();
-        $this->Spreadsheet_Excel_Writer_BIFFwriter();
+        $this->_BIFF_version   = $BIFF_version;
         $rowmax                = 65536; // 16384 in Excel 5
         $colmax                = 256;
         $this->name            = $name;
         $this->index           = $index;
+        $this->activesheet     = &$activesheet;
+        $this->firstsheet      = &$firstsheet;
+        $this->_str_total      = &$str_total;
-        $this->activesheet     = &$activesheet;
+        $this->_str_unique     = &$str_unique;
-        $this->firstsheet      = &$firstsheet;
+        $this->_str_table      = &$str_table;
         $this->_url_format     = &$url_format;
         $this->_parser         = &$parser;
         //$this->ext_sheets      = array();
-        $this->_filehandle     = "";
+        $this->_filehandle     = '';
         $this->_using_tmpfile  = true;
         //$this->fileclosed      = 0;
         $this->_margin_left     = 0.75;
         $this->_margin_right    = 0.75;
         $this->_margin_top      = 1.00;
         $this->_margin_bottom   = 1.00;
-        $this->title_rowmin     = NULL;
+        $this->title_rowmin     = null;
-        $this->title_rowmax     = NULL;
+        $this->title_rowmax     = null;
-        $this->title_colmin     = NULL;
+        $this->title_colmin     = null;
-        $this->title_colmax     = NULL;
+        $this->title_colmax     = null;
-        $this->print_rowmin     = NULL;
+        $this->print_rowmin     = null;
-        $this->print_rowmax     = NULL;
+        $this->print_rowmax     = null;
-        $this->print_colmin     = NULL;
+        $this->print_colmin     = null;
-        $this->print_colmax     = NULL;
+        $this->print_colmax     = null;
         $this->_print_gridlines  = 1;
-        $this->_print_gridlines = 1;
+        $this->_screen_gridlines = 1;
-        $this->_print_headers   = 0;
+        $this->_print_headers    = 0;
         $this->_fit_page        = 0;
         $this->_fit_width       = 0;
         $this->_fit_height      = 0;
         $this->_hbreaks         = array();
         $this->_vbreaks         = array();
         $this->_protect         = 0;
+        $this->_password        = null;
+        $this->col_sizes        = array();
+        $this->_row_sizes        = array();
+        $this->_zoom            = 100;
+        $this->_print_scale     = 100;
+        $this->_outline_row_level = 0;
+        $this->_outline_style     = 0;
+        $this->_outline_below     = 1;
+        $this->_outline_right     = 1;
+        $this->_outline_on        = 1;
+        $this->_Arabic            = 0;
+        $this->_merged_ranges     = array();
         $this->_password        = NULL;
         $this->_input_encoding    = '';
         $this->col_sizes        = array();
-        $this->row_sizes        = array();
+        $this->_dv                = array();
+    *
     * @access private
     */
     function _initialize()
+    {
+        if ($this->_using_tmpfile == false) {
+            return;
+        }
+        if ($this->_tmp_dir === '' && ini_get('open_basedir') === true) {
+            // open_basedir restriction in effect - store data in memory
+            // ToDo: Let the error actually have an effect somewhere
+            $this->_using_tmpfile = false;
+            return new PEAR_Error('Temp file could not be opened since open_basedir restriction in effect - please use setTmpDir() - using memory storage instead');
+        }
         // Open tmp file for storing Worksheet data
+        if ($this->_tmp_dir === '') {
-        $fh = tmpfile();
+            $fh = tmpfile();
-        if ( $fh) {
+        } else {
-            // Store filehandle
+            // For people with open base dir restriction
+            $this->_tmp_file = tempnam($this->_tmp_dir, "Spreadsheet_Excel_Writer");
-            $this->_filehandle = $fh;
+            $fh = @fopen($this->_tmp_file, "w+b");
+        }
-        else {
+        if ($fh === false) {
             // If tmpfile() fails store data in memory
             $this->_using_tmpfile = false;
+        } else {
+            // Store filehandle
+            $this->_filehandle = $fh;
+        }
+    }
     /**
         /***********************************************
         * Prepend in reverse order!!
         */
         // Prepend the sheet dimensions
-        $this->storeDimensions();
+        $this->_storeDimensions();
         // Prepend the sheet password
         $this->_storePassword();
         // Prepend the sheet protection
+        $this->_storeProtect();
         $this->_storeProtect();
         // Prepend the page setup
-        // Prepend the page setup
+        $this->_storeSetup();
         $this->_storeSetup();
         $this->_storeWsbool();
         // Prepend GRIDSET
+        $this->_storeGridset();
+         //  Prepend GUTS
+        if ($this->_BIFF_version == 0x0500) {
+            $this->_storeGuts();
         $this->_storeGridset();
         // Prepend PRINTGRIDLINES
         $this->_storePrintGridlines();
+        // Prepend PRINTHEADERS
-        // Prepend PRINTHEADERS
+        $this->_storePrintHeaders();
-        $this->_storePrintHeaders();
         // Prepend EXTERNSHEET references
-        for ($i = $num_sheets; $i > 0; $i--)
+        if ($this->_BIFF_version == 0x0500) {
+            for ($i = $num_sheets; $i > 0; $i--) {
                 $sheetname = $sheetnames[$i-1];
+                $this->_storeExternsheet($sheetname);
             $sheetname = $sheetnames[$i-1];
+        }
             $this->_storeExternsheet($sheetname);
-        }
+        // Prepend the EXTERNCOUNT of external references.
+        if ($this->_BIFF_version == 0x0500) {
-        // Prepend the EXTERNCOUNT of external references.
+            $this->_storeExterncount($num_sheets);
         $this->_storeExterncount($num_sheets);
         // Prepend the COLINFO records if they exist
-        if (!empty($this->_colinfo))
+        if (!empty($this->_colinfo)) {
         $this->_storeZoom();
         if (!empty($this->_panes)) {
             $this->_storePanes($this->_panes);
+        }
         $this->_storeSelection($this->_selection);
+        $this->_storeMergedCells();
+        /* TODO: add data validity */
+        /*if ($this->_BIFF_version == 0x0600) {
+            $this->_storeDataValidity();
+        }*/
         $this->_storeEof();
+        if ( $this->_tmp_file != '' ) {
+          if ( $this->_filehandle ) {
+            fclose($this->_filehandle);
+            $this->_filehandle = '';
+          }
+          @unlink($this->_tmp_file);
+          $this->_tmp_file      = '';
+          $this->_using_tmpfile = true;
+        }
+    }
     /**
     * Retrieve the worksheet name.
     function getData()
+    {
         $buffer = 4096;
         // Return data stored in memory
-        if (isset($this->_data))
         if (isset($this->_data)) {
             $tmp   = $this->_data;
             unset($this->_data);
             $fh    = $this->_filehandle;
             if ($this->_using_tmpfile) {
                 fseek($fh, 0);
             }
-            return($tmp);
+            return $tmp;
+        }
         // Return data stored on disk
-        if ($this->_using_tmpfile)
         if ($this->_using_tmpfile) {
             if ($tmp = fread($this->_filehandle, $buffer)) {
-                return($tmp);
+                return $tmp;
+            }
+        }
+        // No data to return
+        return '';
+    }
+    /**
+    * Sets a merged cell range
+    *
+    * @access public
+    * @param integer $first_row First row of the area to merge
+    * @param integer $first_col First column of the area to merge
+    * @param integer $last_row  Last row of the area to merge
+    * @param integer $last_col  Last column of the area to merge
+    */
+    function setMerge($first_row, $first_col, $last_row, $last_col)
+    {
+        if (($last_row < $first_row) || ($last_col < $first_col)) {
+            return;
+        }
+        $max_record_ranges = floor(($this->_limit - 6) / 8);
+        if($this->_merged_cells_counter >= $max_record_ranges)
+          {
+            $this->_merged_cells_record++;
+            $this->_merged_cells_counter = 0;
+          }
+        // don't check rowmin, rowmax, etc... because we don't know when this
+        // is going to be called
-        // No data to return
+        $this->_merged_ranges[$this->_merged_cells_record][] = array($first_row, $first_col, $last_row, $last_col);
-        return('');
+        $this->_merged_cells_counter++;
+    }
     * @param integer $firstcol first column on the range
     * @param integer $lastcol  last column on the range
     * @param integer $width    width to set
     * @param mixed   $format   The optional XF format to apply to the columns
     * @param integer $hidden   The optional hidden atribute
+    * @param integer $level    The optional outline level
     */
-    function setColumn($firstcol, $lastcol, $width, $format = 0, $hidden = 0)
+    function setColumn($firstcol, $lastcol, $width, $format = null, $hidden = 0, $level = 0)
+    { // added by Dan Lynn <dan@spiderweblabs.com) on 2006-12-06
+        // look for any ranges this might overlap and remove, size or split where necessary
+        foreach ($this->_colinfo as $key => $colinfo)
-    {
+        {
+            $existing_start = $colinfo[0]; $existing_end = $colinfo[1];
+            // if the new range starts within another range
+            if ($firstcol > $existing_start && $firstcol < $existing_end)
+            { // trim the existing range to the beginning of the new range
+                $this->_colinfo[$key][1] = $firstcol - 1;
+                // if the new range lies WITHIN the existing range
+                if ($lastcol < $existing_end)
+                { // split the existing range by adding a range after our new range
+                    $this->_colinfo[] = array($lastcol+1, $existing_end, $colinfo[2], &$colinfo[3], $colinfo[4], $colinfo[5]);
+                }
+            } // if the new range ends inside an existing range
+            elseif ($lastcol > $existing_start && $lastcol < $existing_end)
+            { // trim the existing range to the end of the new range
+                $this->_colinfo[$key][0] = $lastcol + 1;
+            } // if the new range completely overlaps the existing range
+            elseif ($firstcol <= $existing_start && $lastcol >= $existing_end)
+            {
+                unset($this->_colinfo[$key]);
+            }
+        } // added by Dan Lynn <dan@spiderweblabs.com) on 2006-12-06
+        // regenerate keys
+        $this->_colinfo = array_values($this->_colinfo);
-        $this->_colinfo[] = array($firstcol, $lastcol, $width, &$format, $hidden);
+        $this->_colinfo[] = array($firstcol, $lastcol, $width, &$format, $hidden, $level);
         // Set width to zero if column is hidden
         $width = ($hidden) ? 0 : $width;
-        for($col = $firstcol; $col <= $lastcol; $col++) {
+        for ($col = $firstcol; $col <= $lastcol; $col++)
+        {
             $this->col_sizes[$col] = $width;
+        }
+    }
+    *
     * @access public
     * @param integer $first_row First row to repeat
     * @param integer $last_row  Last row to repeat. Optional.
     */
-    function repeatRows($first_row, $last_row = NULL)
+    function repeatRows($first_row, $last_row = null)
+    {
         $this->title_rowmin  = $first_row;
         if (isset($last_row)) { //Second row is optional
             $this->title_rowmax  = $last_row;
-        }
-        else {
+        } else {
             $this->title_rowmax  = $first_row;
+        }
+    }
+    *
     * @access public
     * @param integer $first_col First column to repeat
     * @param integer $last_col  Last column to repeat. Optional.
     */
-    function repeatColumns($first_col, $last_col = NULL)
+    function repeatColumns($first_col, $last_col = null)
+    {
         $this->title_colmin  = $first_col;
         if (isset($last_col)) { // Second col is optional
             $this->title_colmax  = $last_col;
-        }
-        else {
+        } else {
             $this->title_colmax  = $first_col;
+        }
+    }
+    {
         $this->_print_gridlines = 0;
+    }
+    /**
+    * Set the option to hide gridlines on the worksheet (as seen on the screen).
+    *
+    * @access public
+    */
+    function hideScreenGridlines()
+    {
+        $this->_screen_gridlines = 0;
+    }
     /**
     * Set the option to print the row and column headers on the printed page.
+    *
     * @access public
     * @param integer $print Whether to print the headers or not. Defaults to 1 (print).
     * @param integer $scale The zoom factor
     */
     function setZoom($scale = 100)
+    {
         // Confine the scale to Excel's range
-        if ($scale < 10 or $scale > 400)
+        if ($scale < 10 || $scale > 400) {
-        {
             $this->raiseError("Zoom factor $scale outside range: 10 <= zoom <= 400");
             $scale = 100;
+        }
     * @param integer $scale The optional scale factor. Defaults to 100
     */
     function setPrintScale($scale = 100)
+    {
         // Confine the scale to Excel's range
-        if ($scale < 10 or $scale > 400)
+        if ($scale < 10 || $scale > 400) {
-        {
             $this->raiseError("Print scale $scale outside range: 10 <= zoom <= 400");
             $scale = 100;
+        }
     * @param integer $row    The row of the cell we are writing to
     * @param integer $col    The column of the cell we are writing to
     * @param mixed   $token  What we are writing
     * @param mixed   $format The optional format to apply to the cell
     */
-    function write($row, $col, $token, $format = 0)
+    function write($row, $col, $token, $format = null)
+    {
         // Check for a cell reference in A1 notation and substitute row and column
         /*if ($_[0] =~ /^\D/) {
             @_ = $this->_substituteCellref(@_);
     }*/
         // Match number
+        if (preg_match("/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/", $token)) {
-        if (preg_match("/^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/",$token)) {
+            // Match number
-            return $this->writeNumber($row,$col,$token,$format);
+            return $this->writeNumber($row, $col, $token, $format);
         } elseif (preg_match("/^[fh]tt?p:\/\//", $token)) {
-        // Match http or ftp URL
-        elseif (preg_match("/^[fh]tt?p:\/\//",$token)) {
+            // Match http or ftp URL
-            return $this->writeUrl($row, $col, $token, $format);
+            return $this->writeUrl($row, $col, $token, '', $format);
         } elseif (preg_match("/^mailto:/", $token)) {
-        // Match mailto:
-        elseif (preg_match("/^mailto:/",$token)) {
+            // Match mailto:
-            return $this->writeUrl($row, $col, $token, $format);
+            return $this->writeUrl($row, $col, $token, '', $format);
         } elseif (preg_match("/^(?:in|ex)ternal:/", $token)) {
-        // Match internal or external sheet link
-        elseif (preg_match("/^(?:in|ex)ternal:/",$token)) {
+            // Match internal or external sheet link
-            return $this->writeUrl($row, $col, $token, $format);
+            return $this->writeUrl($row, $col, $token, '', $format);
         } elseif (preg_match("/^=/", $token)) {
-        // Match formula
-        elseif (preg_match("/^=/",$token)) {
+            // Match formula
-            return $this->writeFormula($row, $col, $token, $format);
-        }
-        // Match formula
+            return $this->writeFormula($row, $col, $token, $format);
-        elseif (preg_match("/^@/",$token)) {
-            return $this->writeFormula($row, $col, $token, $format);
         } elseif ($token == '') {
-        // Match blank
-        elseif ($token == '') {
+            // Match blank
-            return $this->writeBlank($row,$col,$format);
+            return $this->writeBlank($row, $col, $format);
         } else {
-        // Default: match string
-        else {
+            // Default: match string
-            return $this->writeString($row,$col,$token,$format);
+            return $this->writeString($row, $col, $token, $format);
+        }
+    }
     /**
     * Write an array of values as a row
     *
+    * @access public
+    * @param integer $row    The row we are writing to
+    * @param integer $col    The first col (leftmost col) we are writing to
-    * @access public
+    * @param array   $val    The array of values to write
-    * @param
+    * @param mixed   $format The optional format to apply to the cell
-    * @return
+    * @return mixed PEAR_Error on failure
     */
     function writeRow($row, $col, $val, $format = null)
     function writeRow($row, $col, $val, $format=0)
         $retval = '';
         if (is_array($val)) {
-            foreach($val as $v) {
+            foreach ($val as $v) {
     /**
     * Write an array of values as a column
+    *
+    * @access public
-    * @access public
+    * @param integer $row    The first row (uppermost row) we are writing to
+    * @param integer $col    The col we are writing to
+    * @param array   $val    The array of values to write
-    * @param
+    * @param mixed   $format The optional format to apply to the cell
-    * @return
+    * @return mixed PEAR_Error on failure
     */
+    function writeCol($row, $col, $val, $format = null)
     function writeCol($row, $col, $val, $format=0)
         $retval = '';
         if (is_array($val)) {
-            foreach($val as $v) {
+            foreach ($val as $v) {
                 $this->write($row, $col, $v, $format);
     * @param mixed &$format The optional XF format
     * @return integer The XF record index
     */
     function _XF(&$format)
+    {
-        if ($format != 0) {
+        if ($format) {
             return($format->getXfIndex());
-        }
-        else {
+        } else {
             return(0x0F);
+        }
+    }
     * @access private
     * @param string $data The binary data to append
     */
     function _append($data)
+    {
-        if ($this->_using_tmpfile)
+        if ($this->_using_tmpfile) {
-        {
             // Add CONTINUE records if necessary
             if (strlen($data) > $this->_limit) {
                 $data = $this->_addContinue($data);
+            }
-            fwrite($this->_filehandle,$data);
+            fwrite($this->_filehandle, $data);
             $this->_datasize += strlen($data);
-        }
-        else {
+        } else {
             parent::_append($data);
+        }
+    }
         $password = 0x0000;
         $i        = 1;       // char position
         // split the plain text password in its component characters
         $chars = preg_split('//', $plaintext, -1, PREG_SPLIT_NO_EMPTY);
-        foreach($chars as $char)
         foreach ($chars as $char) {
             $value        = ord($char) << $i;   // shifted ASCII value
             $rotated_bits = $value >> 15;       // rotated bits beyond bit 15
             $value       &= 0x7fff;             // first 15 bits
             $password    ^= ($value | $rotated_bits);
         $password ^= 0xCE4B;
         return($password);
+    }
+    /**
+    * This method sets the properties for outlining and grouping. The defaults
+    * correspond to Excel's defaults.
+    *
+    * @param bool $visible
+    * @param bool $symbols_below
+    * @param bool $symbols_right
+    * @param bool $auto_style
+    */
+    function setOutline($visible = true, $symbols_below = true, $symbols_right = true, $auto_style = false)
+    {
+        $this->_outline_on    = $visible;
+        $this->_outline_below = $symbols_below;
+        $this->_outline_right = $symbols_right;
+        $this->_outline_style = $auto_style;
+        // Ensure this is a boolean vale for Window2
+        if ($this->_outline_on) {
+            $this->_outline_on = 1;
+        }
+     }
+    /**
+    * This method sets the worksheet direction to right-to-left (RTL)
+    *
+    * @param bool $rtl
+    */
+    function setRTL($rtl = true)
+    {
         $this->_Arabic = ($rtl ? 1 : 0);
+     }
     /******************************************************************************
     * @param integer $col    Zero indexed column
     * @param float   $num    The number to write
     * @param mixed   $format The optional XF format
     * @return integer
     */
-    function writeNumber($row, $col, $num, $format = 0)
+    function writeNumber($row, $col, $num, $format = null)
+    {
         $record    = 0x0203;                 // Record identifier
         $length    = 0x000E;                 // Number of bytes to follow
         $xf        = $this->_XF($format);    // The cell format
-        // Check that row and col are valid and store max and min values
-        if ($row >= $this->_xls_rowmax)
+        // Check that row and col are valid and store max and min values
         if ($row >= $this->_xls_rowmax) {
             return(-2);
-        }
         if ($col >= $this->_xls_colmax)
         if ($col >= $this->_xls_colmax) {
             return(-2);
-        }
         if ($row <  $this->_dim_rowmin)
         if ($row <  $this->_dim_rowmin)  {
             $this->_dim_rowmin = $row;
-        }
         if ($row >  $this->_dim_rowmax)
         if ($row >  $this->_dim_rowmax)  {
             $this->_dim_rowmax = $row;
-        }
         if ($col <  $this->_dim_colmin)
         if ($col <  $this->_dim_colmin)  {
             $this->_dim_colmin = $col;
-        }
         if ($col >  $this->_dim_colmax)
         if ($col >  $this->_dim_colmax)  {
             $this->_dim_colmax = $col;
+        }
         $header    = pack("vv",  $record, $length);
-        $data      = pack("vvv", $row, $col, $xf);
-        $xl_double = pack("d",   $num);
+        $data      = pack("vvv", $row, $col, $xf);
-        if ($this->_byte_order) // if it's Big Endian
+        $xl_double = pack("d",   $num);
         if ($this->_byte_order) { // if it's Big Endian
             $xl_double = strrev($xl_double);
     * @param integer $col    Zero indexed column
     * @param string  $str    The string to write
     * @param mixed   $format The XF format for the cell
     * @return integer
     */
-    function writeString($row, $col, $str, $format = 0)
+    function writeString($row, $col, $str, $format = null)
+    {
+        if ($this->_BIFF_version == 0x0600) {
+            return $this->writeStringBIFF8($row, $col, $str, $format);
+        }
         $strlen    = strlen($str);
         $record    = 0x0204;                   // Record identifier
         $length    = 0x0008 + $strlen;         // Bytes to follow
         $xf        = $this->_XF($format);      // The cell format
         $str_error = 0;
-        // Check that row and col are valid and store max and min values
-        if ($row >= $this->_xls_rowmax)
+        // Check that row and col are valid and store max and min values
         if ($row >= $this->_xls_rowmax) {
             return(-2);
-        }
         if ($col >= $this->_xls_colmax)
         if ($col >= $this->_xls_colmax) {
             return(-2);
-        }
         if ($row <  $this->_dim_rowmin)
         if ($row <  $this->_dim_rowmin) {
             $this->_dim_rowmin = $row;
-        }
         if ($row >  $this->_dim_rowmax)
         if ($row >  $this->_dim_rowmax) {
             $this->_dim_rowmax = $row;
-        }
         if ($col <  $this->_dim_colmin)
         if ($col <  $this->_dim_colmin) {
             $this->_dim_colmin = $col;
-        }
         if ($col >  $this->_dim_colmax)
         if ($col >  $this->_dim_colmax) {
             $this->_dim_colmax = $col;
-        }
+        }
         if ($strlen > $this->_xls_strmax)  // LABEL must be < 255 chars
         if ($strlen > $this->_xls_strmax) { // LABEL must be < 255 chars
             $str       = substr($str, 0, $this->_xls_strmax);
             $length    = 0x0008 + $this->_xls_strmax;
-        $this->_append($header.$data.$str);
+        $this->_append($header . $data . $str);
         return($str_error);
+    }
+    /**
+    * Sets Input Encoding for writing strings
+    *
+    * @access public
+    * @param string $encoding The encoding. Ex: 'UTF-16LE', 'utf-8', 'ISO-859-7'
+    */
+    function setInputEncoding($encoding)
+    {
+         if ($encoding != 'UTF-16LE' && !function_exists('iconv')) {
+             $this->raiseError("Using an input encoding other than UTF-16LE requires PHP support for iconv");
+         }
+         $this->_input_encoding = $encoding;
+    }
+    /**
+    * Write a string to the specified row and column (zero indexed).
+    * This is the BIFF8 version (no 255 chars limit).
+    * $format is optional.
+    * Returns  0 : normal termination
+    *         -2 : row or column out of range
+    *         -3 : long string truncated to 255 chars
+    *
+    * @access public
+    * @param integer $row    Zero indexed row
+    * @param integer $col    Zero indexed column
+    * @param string  $str    The string to write
+    * @param mixed   $format The XF format for the cell
+    * @return integer
+    */
+    function writeStringBIFF8($row, $col, $str, $format = null)
+    {
+        if ($this->_input_encoding == 'UTF-16LE')
+        {
+            $strlen = function_exists('mb_strlen') ? mb_strlen($str, 'UTF-16LE') : (strlen($str) / 2);
+            $encoding  = 0x1;
+        }
+        elseif ($this->_input_encoding != '')
+        {
+            $str = iconv($this->_input_encoding, 'UTF-16LE', $str);
+            $strlen = function_exists('mb_strlen') ? mb_strlen($str, 'UTF-16LE') : (strlen($str) / 2);
+            $encoding  = 0x1;
+        }
+        else
+        {
+            $strlen    = strlen($str);
+            $encoding  = 0x0;
+        }
+        $record    = 0x00FD;                   // Record identifier
+        $length    = 0x000A;                   // Bytes to follow
+        $xf        = $this->_XF($format);      // The cell format
+        $str_error = 0;
+        // Check that row and col are valid and store max and min values
+        if ($this->_checkRowCol($row, $col) == false) {
+            return -2;
+        }
+        $str = pack('vC', $strlen, $encoding).$str;
+        /* check if string is already present */
+        if (!isset($this->_str_table[$str])) {
+            $this->_str_table[$str] = $this->_str_unique++;
+        }
+        $this->_str_total++;
+        $header    = pack('vv',   $record, $length);
+        $data      = pack('vvvV', $row, $col, $xf, $this->_str_table[$str]);
+        $this->_append($header.$data);
+        return $str_error;
+    }
+    /**
+    * Check row and col before writing to a cell, and update the sheet's
+    * dimensions accordingly
+    *
+    * @access private
+    * @param integer $row    Zero indexed row
+    * @param integer $col    Zero indexed column
+    * @return boolean true for success, false if row and/or col are grester
+    *                 then maximums allowed.
+    */
+    function _checkRowCol($row, $col)
+    {
+        if ($row >= $this->_xls_rowmax) {
+            return false;
+        }
+        if ($col >= $this->_xls_colmax) {
+            return false;
+        }
+        if ($row <  $this->_dim_rowmin) {
+            $this->_dim_rowmin = $row;
+        }
+        if ($row >  $this->_dim_rowmax) {
+            $this->_dim_rowmax = $row;
+        }
+        if ($col <  $this->_dim_colmin) {
+            $this->_dim_colmin = $col;
+        }
+        if ($col >  $this->_dim_colmax) {
+            $this->_dim_colmax = $col;
+        }
+        return true;
+    }
     /**
     * Writes a note associated with the cell given by the row and column.
     * NOTE records don't have a length limit.
+    *
     * @access public
         $record         = 0x001C;                // Record identifier
         $max_length     = 2048;                  // Maximun length for a NOTE record
         //$length      = 0x0006 + $note_length;    // Bytes to follow
         // Check that row and col are valid and store max and min values
-        if ($row >= $this->_xls_rowmax)
         if ($row >= $this->_xls_rowmax) {
             return(-2);
         }
-        if ($col >= $this->_xls_colmax)
         if ($col >= $this->_xls_colmax) {
             return(-2);
         }
-        if ($row <  $this->_dim_rowmin)
         if ($row <  $this->_dim_rowmin) {
             $this->_dim_rowmin = $row;
         }
-        if ($row >  $this->_dim_rowmax)
         if ($row >  $this->_dim_rowmax) {
             $this->_dim_rowmax = $row;
         }
-        if ($col <  $this->_dim_colmin)
         if ($col <  $this->_dim_colmin) {
             $this->_dim_colmin = $col;
         }
-        if ($col >  $this->_dim_colmax)
         if ($col >  $this->_dim_colmax) {
             $this->_dim_colmax = $col;
+        }
         // Length for this record is no more than 2048 + 6
         $length    = 0x0006 + min($note_length, 2048);
         $header    = pack("vv",   $record, $length);
         $data      = pack("vvv", $row, $col, $note_length);
-        $this->_append($header.$data.substr($note, 0, 2048));
         $this->_append($header . $data . substr($note, 0, 2048));
         for($i = $max_length; $i < $note_length; $i += $max_length)
         for ($i = $max_length; $i < $note_length; $i += $max_length) {
             $chunk  = substr($note, $i, $max_length);
             $length = 0x0006 + strlen($chunk);
     * @param mixed   $format The XF format
     */
     function writeBlank($row, $col, $format)
+    {
         // Don't write a blank cell unless it has a format
-        if ($format == 0)
+        if (!$format) {
-        {
             return(0);
+        }
         $record    = 0x0201;                 // Record identifier
         $length    = 0x0006;                 // Number of bytes to follow
         $xf        = $this->_XF($format);    // The cell format
-        // Check that row and col are valid and store max and min values
-        if ($row >= $this->_xls_rowmax)
+        // Check that row and col are valid and store max and min values
         if ($row >= $this->_xls_rowmax) {
             return(-2);
-        }
         if ($col >= $this->_xls_colmax)
         if ($col >= $this->_xls_colmax) {
             return(-2);
-        }
         if ($row <  $this->_dim_rowmin)
         if ($row <  $this->_dim_rowmin) {
             $this->_dim_rowmin = $row;
-        }
         if ($row >  $this->_dim_rowmax)
         if ($row >  $this->_dim_rowmax) {
             $this->_dim_rowmax = $row;
-        }
         if ($col <  $this->_dim_colmin)
         if ($col <  $this->_dim_colmin) {
             $this->_dim_colmin = $col;
-        }
         if ($col >  $this->_dim_colmax)
         if ($col >  $this->_dim_colmax) {
             $this->_dim_colmax = $col;
+        }
     * @param integer $col     Zero indexed column
     * @param string  $formula The formula text string
     * @param mixed   $format  The optional XF format
     * @return integer
     */
-    function writeFormula($row, $col, $formula, $format = 0)
+    function writeFormula($row, $col, $formula, $format = null)
+    {
         $record    = 0x0006;     // Record identifier
         // Excel normally stores the last calculated value of the formula in $num.
         // automatic calculation of the formula when the file is opened.
         //
         $xf        = $this->_XF($format); // The cell format
         $num       = 0x00;                // Current value of formula
         $grbit     = 0x03;                // Option flags
-        $chn       = 0x0000;              // Must be zero
+        $unknown   = 0x0000;              // Must be zero
-        // Check that row and col are valid and store max and min values
-        if ($row >= $this->_xls_rowmax)
+        // Check that row and col are valid and store max and min values
-        {
-            return(-2);
-        }
-        if ($col >= $this->_xls_colmax)
-        {
-            return(-2);
-        }
-        if ($row <  $this->_dim_rowmin)
-        {
-            $this->_dim_rowmin = $row;
-        }
-        if ($row >  $this->_dim_rowmax)
-        {
-            $this->_dim_rowmax = $row;
-        }
-        if ($col <  $this->_dim_colmin)
-        {
-            $this->_dim_colmin = $col;
-        }
-        if ($col >  $this->_dim_colmax)
         if ($this->_checkRowCol($row, $col) == false) {
-            $this->_dim_colmax = $col;
+            return -2;
+        }
-        // Strip the '=' or '@' sign at the beginning of the formula string
-        if (preg_match("/^=/",$formula)) {
+        // Strip the '=' or '@' sign at the beginning of the formula string
-            $formula = preg_replace("/(^=)/","",$formula);
+        if (preg_match("/^=/", $formula)) {
-        }
-        elseif (preg_match("/^@/",$formula)) {
+            $formula = preg_replace("/(^=)/", "", $formula);
-            $formula = preg_replace("/(^@)/","",$formula);
         } elseif (preg_match("/^@/", $formula)) {
-        else
+            $formula = preg_replace("/(^@)/", "", $formula);
         } else {
             // Error handling
             $this->writeString($row, $col, 'Unrecognised character for formula');
             return -1;
         }
         // Parse the formula using the parser in Parser.php
-        $error = $this->_parser->parse($formula);
+        // Parse the formula using the parser in Parser.php
-        if ($this->isError($error))
+        $error = $this->_parser->parse($formula);
         if ($this->isError($error)) {
             $this->writeString($row, $col, $error->getMessage());
-            return -1;
             return -1;
+        }
         $formula = $this->_parser->toReversePolish();
-        if ($this->isError($formula))
+        $formula = $this->_parser->toReversePolish();
         if ($this->isError($formula)) {
             $this->writeString($row, $col, $formula->getMessage());
             return -1;
         }
         $formlen    = strlen($formula);    // Length of the binary string
         $length     = 0x16 + $formlen;     // Length of the record data
     * @param string  $url    URL string
     * @param string  $string Alternative label
     * @param mixed   $format The cell format
     * @return integer
     */
-    function writeUrl($row, $col, $url, $string = '', $format = 0)
+    function writeUrl($row, $col, $url, $string = '', $format = null)
+    {
         // Add start row and col to arg list
-        return($this->_writeUrl_range($row, $col, $row, $col, $url, $string, $format));
+        return($this->_writeUrlRange($row, $col, $row, $col, $url, $string, $format));
+    }
     /**
     * This is the more general form of writeUrl(). It allows a hyperlink to be
     * @param string  $string Alternative label
     * @param mixed   $format The cell format
     * @return integer
     */
-    function _writeUrl_range($row1, $col1, $row2, $col2, $url, $string = '', $format = 0)
+    function _writeUrlRange($row1, $col1, $row2, $col2, $url, $string = '', $format = null)
+    {
         // Check for internal/external sheet links or default to web link
     * @param string  $url    URL string
     * @param string  $str    Alternative label
     * @param mixed   $format The cell format
     * @return integer
     */
-    function _writeUrlWeb($row1, $col1, $row2, $col2, $url, $str, $format = 0)
+    function _writeUrlWeb($row1, $col1, $row2, $col2, $url, $str, $format = null)
+    {
         $record      = 0x01B8;                       // Record identifier
         $length      = 0x00000;                      // Bytes to follow
-        if ($format == 0) {
+        if (!$format) {
             $format = $this->_url_format;
+        }
         // Write the visible label using the writeString() method.
         if ($str == '') {
             $str = $url;
         }
-        $str_error = $this->writeString($row1, $col1, $str, $format);
+        $str_error = is_numeric($str) ? $this->writeNumber($row1, $col1, $str, $format) : $this->writeString($row1, $col1, $str, $format);
-        if (($str_error == -2) or ($str_error == -3)) {
+        if (($str_error == -2) || ($str_error == -3)) {
             return $str_error;
+        }
     * @param string  $url    URL string
     * @param string  $str    Alternative label
     * @param mixed   $format The cell format
     * @return integer
     */
-    function _writeUrlInternal($row1, $col1, $row2, $col2, $url, $str, $format = 0)
+    function _writeUrlInternal($row1, $col1, $row2, $col2, $url, $str, $format = null)
+    {
         $record      = 0x01B8;                       // Record identifier
         $length      = 0x00000;                      // Bytes to follow
-        if ($format == 0) {
+        if (!$format) {
             $format = $this->_url_format;
+        }
         // Strip URL type
-        $url = preg_replace('s[^internal:]', '', $url);
+        $url = preg_replace('/^internal:/', '', $url);
         // Write the visible label
         if ($str == '') {
             $str = $url;
+        }
-        $str_error = $this->writeString($row1, $col1, $str, $format);
+        $str_error = is_numeric($str) ? $this->writeNumber($row1, $col1, $str, $format) : $this->writeString($row1, $col1, $str, $format);
-        if (($str_error == -2) or ($str_error == -3)) {
+        if (($str_error == -2) || ($str_error == -3)) {
             return $str_error;
     * @param string  $url    URL string
     * @param string  $str    Alternative label
     * @param mixed   $format The cell format
     * @return integer
     */
-    function _writeUrlExternal($row1, $col1, $row2, $col2, $url, $str, $format = 0)
+    function _writeUrlExternal($row1, $col1, $row2, $col2, $url, $str, $format = null)
+    {
         // Network drives are different. We will handle them separately
         // MS/Novell network drives and shares start with \\
         if (preg_match('[^external:\\\\]', $url)) {
             return; //($this->_writeUrlExternal_net($row1, $col1, $row2, $col2, $url, $str, $format));
+        }
         $record      = 0x01B8;                       // Record identifier
         $length      = 0x00000;                      // Bytes to follow
-        if ($format == 0) {
+        if (!$format) {
             $format = $this->_url_format;
+        }
         // Strip URL type and change Unix dir separator to Dos style (if needed)
         //
-        $url = preg_replace('[^external:]', '', $url);
+        $url = preg_replace('/^external:/', '', $url);
-        $url = preg_replace('[/]', "\\", $url);
+        $url = preg_replace('/\//', "\\", $url);
         // Write the visible label
         if ($str == '') {
-            $str = preg_replace('[\#]', ' - ', $url);
+            $str = preg_replace('/\#/', ' - ', $url);
+        }
-        $str_error = $this->writeString($row1, $col1, $str, $format);
+        $str_error = is_numeric($str) ? $this->writeNumber($row1, $col1, $str, $format) : $this->writeString($row1, $col1, $str, $format);
         if (($str_error == -2) or ($str_error == -3)) {
             return $str_error;
+        }
         // Determine if the link is relative or absolute:
         //   relative if link contains no dir separator, "somefile.xls"
         //   relative if link starts with up-dir, "..\..\somefile.xls"
         //   otherwise, absolute
         $absolute    = 0x02; // Bit mask
+        if (!preg_match("/\\\/", $url)) {
-        if (!preg_match('[\\]', $url)) {
+            $absolute    = 0x00;
             $absolute    = 0x00;
         if (preg_match("/^\.\.\\\/", $url)) {
+            $absolute    = 0x00;
-        if (preg_match('[^\.\.\\]', $url)) {
+        }
+        $link_type               = 0x01 | $absolute;
-            $absolute    = 0x00;
+        // Determine if the link contains a sheet reference and change some of the
         // parameters accordingly.
         // Split the dir name and sheet name (if it exists)
-        // Determine if the link contains a sheet reference and change some of the
+        /*if (preg_match("/\#/", $url)) {
-        // parameters accordingly.
+            list($dir_long, $sheet) = split("\#", $url);
-        // Split the dir name and sheet name (if it exists)
+        } else {
-        list($dir_long , $sheet) = explode('/\#/', $url);
-        $link_type               = 0x01 | $absolute;
+            $dir_long = $url;
+        }
         if (isset($sheet)) {
+        if (isset($sheet)) {
+            $link_type |= 0x08;
+            $sheet_len  = pack("V", strlen($sheet) + 0x01);
+            $sheet      = join("\0", split('', $sheet));
-            $link_type |= 0x08;
+            $sheet     .= "\0\0\0";
+        } else {
+            $sheet_len   = '';
-            $sheet_len  = pack("V", strlen($sheet) + 0x01);
+            $sheet       = '';
-            $sheet      = join("\0", explode('', $sheet));
+        }*/
-            $sheet     .= "\0\0\0";
+        $dir_long = $url;
-        }
+        if (preg_match("/\#/", $url)) {
-        else {
+            $link_type |= 0x08;
             $sheet_len   = '';
-            $sheet       = '';
         // Pack the link type
         $link_type   = pack("V", $link_type);
         // Calculate the up-level dir count e.g.. (..\..\..\ == 3)
-        $up_count    = preg_match_all("/\.\.\\/", $dir_long, $useless);
+        $up_count    = preg_match_all("/\.\.\\\/", $dir_long, $useless);
         $up_count    = pack("v", $up_count);
         // Store the short dos dir name (null terminated)
-        $dir_short   = preg_replace('/\.\.\\/', '', $dir_long) . "\0";
+        $dir_short   = preg_replace("/\.\.\\\/", '', $dir_long) . "\0";
                           $unknown2     .
                           $up_count     .
                           $dir_short_len.
                           $dir_short    .
                           $unknown3     .
-                          $stream_len   .
+                          $stream_len   ;/*.
                           $dir_long_len .
                           $unknown4     .
                           $dir_long     .
                           $sheet_len    .
-                          $sheet        ;
+                          $sheet        ;*/
         // Pack the header data
         $length   = strlen($data);
     * This method is used to set the height and format for a row.
+    *
     * @access public
     * @param integer $row    The row to set
     * @param integer $height Height we are giving to the row.
-    *                        Use NULL to set XF without setting height
+    *                        Use null to set XF without setting height
     * @param mixed   $format XF format we are giving to the row
+    * @param bool    $hidden The optional hidden attribute
+    * @param integer $level  The optional outline level for row, in range [0,7]
     */
-    function setRow($row, $height, $format = 0)
+    function setRow($row, $height, $format = null, $hidden = false, $level = 0)
+    {
         $record      = 0x0208;               // Record identifier
         $length      = 0x0010;               // Number of bytes to follow
         $colMic      = 0x0000;               // First defined column
         $colMac      = 0x0000;               // Last defined column
         $irwMac      = 0x0000;               // Used by Excel to optimise loading
         $reserved    = 0x0000;               // Reserved
-        $grbit       = 0x01C0;               // Option flags. (monkey) see $1 do
+        $grbit       = 0x0000;               // Option flags
+        $ixfe        = $this->_XF($format);  // XF index
+        // set _row_sizes so _sizeRow() can use it
-        $ixfe        = $this->_XF($format);  // XF index
+        $this->_row_sizes[$row] = $height;
-        // Use setRow($row, NULL, $XF) to set XF format without setting height
+        // Use setRow($row, null, $XF) to set XF format without setting height
-        if ($height != NULL) {
-            $miyRw = $height * 20;  // row height
+        if ($height != null) {
             $miyRw = $height * 20;  // row height
-        else {
+        } else {
+            $miyRw = 0xff;          // default row height is 256
+        }
+        $level = max(0, min($level, 7));  // level should be between 0 and 7
+        $this->_outline_row_level = max($level, $this->_outline_row_level);
+        // Set the options flags. fUnsynced is used to show that the font and row
+        // heights are not compatible. This is usually the case for WriteExcel.
+        // The collapsed flag 0x10 doesn't seem to be used to indicate that a row
+        // is collapsed. Instead it is used to indicate that the previous row is
+        // collapsed. The zero height flag, 0x20, is used to collapse a row.
+        $grbit |= $level;
+        if ($hidden) {
+            $grbit |= 0x0020;
+        }
+        $grbit |= 0x0040; // fUnsynced
+        if ($format) {
+            $grbit |= 0x0080;
             $miyRw = 0xff;          // default row height is 256
         $grbit |= 0x0100;
         $header   = pack("vv",       $record, $length);
         $data     = pack("vvvvvvvv", $row, $colMic, $colMac, $miyRw,
     /**
     * Writes Excel DIMENSIONS to define the area in which there is data.
+    *
     * @access private
     */
-    function storeDimensions()
+    function _storeDimensions()
+    {
-        $record    = 0x0000;               // Record identifier
+        $record    = 0x0200;                 // Record identifier
-        $length    = 0x000A;               // Number of bytes to follow
-        $row_min   = $this->_dim_rowmin;   // First row
+        $row_min   = $this->_dim_rowmin;     // First row
-        $row_max   = $this->_dim_rowmax;   // Last row plus 1
+        $row_max   = $this->_dim_rowmax + 1; // Last row plus 1
-        $col_min   = $this->_dim_colmin;   // First column
+        $col_min   = $this->_dim_colmin;     // First column
-        $col_max   = $this->_dim_colmax;   // Last column plus 1
+        $col_max   = $this->_dim_colmax + 1; // Last column plus 1
-        $reserved  = 0x0000;               // Reserved by Excel
+        $reserved  = 0x0000;                 // Reserved by Excel
+        if ($this->_BIFF_version == 0x0500) {
-        $header    = pack("vv",    $record, $length);
+            $length    = 0x000A;               // Number of bytes to follow
-        $data      = pack("vvvvv", $row_min, $row_max,
+            $data      = pack("vvvvv", $row_min, $row_max,
+                                       $col_min, $col_max, $reserved);
+        } elseif ($this->_BIFF_version == 0x0600) {
+            $length    = 0x000E;
+            $data      = pack("VVvvv", $row_min, $row_max,
+                                       $col_min, $col_max, $reserved);
+        }
-                                   $col_min, $col_max, $reserved);
+        $header = pack("vv", $record, $length);
         $this->_prepend($header.$data);
+    }
     * @access private
     */
     function _storeWindow2()
+    {
         $record         = 0x023E;     // Record identifier
+        if ($this->_BIFF_version == 0x0500) {
-        $length         = 0x000A;     // Number of bytes to follow
+            $length         = 0x000A;     // Number of bytes to follow
+        } elseif ($this->_BIFF_version == 0x0600) {
+            $length         = 0x0012;
+        }
         $grbit          = 0x00B6;     // Option flags
         $rwTop          = 0x0000;     // Top row visible in window
-        $colLeft        = 0x0000;     // Leftmost column visible in window
+        $colLeft        = 0x0000;     // Leftmost column visible in window
         $rgbHdr         = 0x00000000; // Row/column heading and gridline color
         // The options flags that comprise $grbit
         $fDspFmla       = 0;                     // 0 - bit
-        $fDspGrid       = 1;                     // 1
+        $fDspGrid       = $this->_screen_gridlines; // 1
         $fDspRwCol      = 1;                     // 2
         $fFrozen        = $this->_frozen;        // 3
         $fDspZeros      = 1;                     // 4
         $fDefaultHdr    = 1;                     // 5
-        $fArabic        = 0;                     // 6
+        $fArabic        = $this->_Arabic;        // 6
-        $fDspGuts       = 1;                     // 7
+        $fDspGuts       = $this->_outline_on;    // 7
         $fFrozenNoSplit = 0;                     // 0 - bit
         $fSelected      = $this->selected;       // 1
         $grbit            |= $fFrozenNoSplit << 8;
         $grbit            |= $fSelected      << 9;
         $grbit            |= $fPaged         << 10;
         $header  = pack("vv",   $record, $length);
+        $data    = pack("vvv", $grbit, $rwTop, $colLeft);
+        // FIXME !!!
+        if ($this->_BIFF_version == 0x0500) {
+            $rgbHdr         = 0x00000000; // Row/column heading and gridline color
+            $data .= pack("V", $rgbHdr);
+        } elseif ($this->_BIFF_version == 0x0600) {
+            $rgbHdr       = 0x0040; // Row/column heading and gridline color index
+            $zoom_factor_page_break = 0x0000;
+            $zoom_factor_normal     = 0x0000;
+            $data .= pack("vvvvV", $rgbHdr, 0x0000, $zoom_factor_page_break, $zoom_factor_normal, 0x00000000);
         $data    = pack("vvvV", $grbit, $rwTop, $colLeft, $rgbHdr);
         $this->_append($header.$data);
+    }
     *                0 => First formatted column,
     *                1 => Last formatted column,
     *                2 => Col width (8.43 is Excel default),
     *                3 => The optional XF format of the column,
     *                4 => Option flags.
+    *                5 => Optional outline level
     */
     function _storeColinfo($col_array)
+    {
         if (isset($col_array[0])) {
             $colFirst = $col_array[0];
         if (isset($col_array[1])) {
             $colLast = $col_array[1];
+        }
         if (isset($col_array[2])) {
             $coldx = $col_array[2];
-        }
-        else {
+        } else {
             $coldx = 8.43;
+        }
         if (isset($col_array[3])) {
             $format = $col_array[3];
-        }
-        else {
+        } else {
             $format = 0;
+        }
         if (isset($col_array[4])) {
             $grbit = $col_array[4];
-        }
-        else {
+        } else {
             $grbit = 0;
+        }
+        if (isset($col_array[5])) {
+            $level = $col_array[5];
+        } else {
+            $level = 0;
+        }
         $record   = 0x007D;          // Record identifier
         $length   = 0x000B;          // Number of bytes to follow
         $coldx   += 0.72;            // Fudge. Excel subtracts 0.72 !?
         $coldx   *= 256;             // Convert to units of 1/256 of a char
+        $ixfe     = $this->_XF($format);
+        $reserved = 0x00;            // Reserved
-        $ixfe     = $this->_XF($format);
+        $level = max(0, min($level, 7));
-        $reserved = 0x00;            // Reserved
+        $grbit |= $level << 8;
         $header   = pack("vv",     $record, $length);
         $data     = pack("vvvvvC", $colFirst, $colLast, $coldx,
         if (!isset($colLast)) {
             $colLast  = $colFirst;      // Last  col in reference
+        }
         // Swap last row/col for first row/col as necessary
-        if ($rwFirst > $rwLast)
         if ($rwFirst > $rwLast) {
             list($rwFirst, $rwLast) = array($rwLast, $rwFirst);
         }
         if ($colFirst > $colLast)
         if ($colFirst > $colLast) {
             list($colFirst, $colLast) = array($colLast, $colFirst);
+        }
                                        $rwFirst, $rwLast,
                                        $colFirst, $colLast);
-        $this->_append($header.$data);
+        $this->_append($header . $data);
+    }
+    /**
+    * Store the MERGEDCELLS record for all ranges of merged cells
+    *
+    * @access private
+    */
+    function _storeMergedCells()
+    {
+        // if there are no merged cell ranges set, return
+        if (count($this->_merged_ranges) == 0) {
+            return;
+        }
+        $record   = 0x00E5;
+        foreach($this->_merged_ranges as $ranges)
+          {
+            $length   = 2 + count($ranges) * 8;
+            $header   = pack('vv', $record, $length);
+            $data     = pack('v',  count($ranges));
+            foreach($ranges as $range)
+              $data .= pack('vvvv', $range[0], $range[2], $range[1], $range[3]);
+            $string=$header.$data;
+            $this->_append(&$string, true);
+          }
+    }
     /**
     * Write BIFF record EXTERNCOUNT to indicate the number of external sheet
         if ($this->name == $sheetname) {
             $sheetname = '';
             $length    = 0x02;  // The following 2 bytes
             $cch       = 1;     // The following byte
             $rgch      = 0x02;  // Self reference
-        }
-        else {
+        } else {
             $length    = 0x02 + strlen($sheetname);
             $cch       = strlen($sheetname);
             $rgch      = 0x03;  // Reference to a sheet in the current workbook
+        }
         $x       = $panes[1];
         $rwTop   = $panes[2];
         $colLeft = $panes[3];
         if (count($panes) > 4) { // if Active pane was received
             $pnnAct = $panes[4];
-        }
-        else {
+        } else {
-            $pnnAct = NULL;
+            $pnnAct = null;
+        }
         $record  = 0x0041;       // Record identifier
         $length  = 0x000A;       // Number of bytes to follow
         // Code specific to frozen or thawed panes.
-        if ($this->_frozen)
         if ($this->_frozen) {
             // Set default values for $rwTop and $colLeft
             if (!isset($rwTop)) {
                 $rwTop   = $y;
+            }
             if (!isset($colLeft)) {
                 $colLeft = $x;
-            }
-        }
+            }
-        else
         } else {
             // Set default values for $rwTop and $colLeft
             if (!isset($rwTop)) {
                 $rwTop   = 0;
+            }
         // Determine which pane should be active. There is also the undocumented
         // option to override this should it be necessary: may be removed later.
-        //
-        if (!isset($pnnAct))
+        //
         if (!isset($pnnAct)) {
+            if ($x != 0 && $y != 0) {
-            if ($x != 0 and $y != 0)
+                $pnnAct = 0; // Bottom right
                 $pnnAct = 0; // Bottom right
+            if ($x != 0 && $y == 0) {
-            if ($x != 0 and $y == 0)
+                $pnnAct = 1; // Top right
                 $pnnAct = 1; // Top right
+            if ($x == 0 && $y != 0) {
-            if ($x == 0 and $y != 0)
+                $pnnAct = 2; // Bottom left
                 $pnnAct = 2; // Bottom left
-            if ($x == 0 and $y == 0)
+            if ($x == 0 && $y == 0) {
+                $pnnAct = 3; // Top left
                 $pnnAct = 3; // Top left
+        }
         $grbit          |= $fNoOrient     << 6;
         $grbit          |= $fUsePage      << 7;
         $numHdr = pack("d", $numHdr);
         $numFtr = pack("d", $numFtr);
-        if ($this->_byte_order) // if it's Big Endian
         if ($this->_byte_order) { // if it's Big Endian
             $numHdr = strrev($numHdr);
             $numFtr = strrev($numFtr);
+        }
+    {
         $record  = 0x0014;               // Record identifier
-        $str     = $this->_header;       // header string
+        $str      = $this->_header;       // header string
+        $cch      = strlen($str);         // Length of header string
+        if ($this->_BIFF_version == 0x0600) {
+            $encoding = 0x0;                  // TODO: Unicode support
+            $length   = 3 + $cch;             // Bytes to follow
-        $cch     = strlen($str);         // Length of header string
+        } else {
+            $length  = 1 + $cch;             // Bytes to follow
         $length  = 1 + $cch;             // Bytes to follow
+        $header   = pack("vv", $record, $length);
+        if ($this->_BIFF_version == 0x0600) {
             $data     = pack("vC",  $cch, $encoding);
+        } else {
-        $header    = pack("vv", $record, $length);
+            $data      = pack("C",  $cch);
         $data      = pack("C",  $cch);
-        $this->_append($header.$data.$str);
+        $this->_prepend($header.$data.$str);
+    }
+    {
         $record  = 0x0015;               // Record identifier
-        $str     = $this->_footer;       // Footer string
+        $str      = $this->_footer;       // Footer string
+        $cch      = strlen($str);         // Length of footer string
+        if ($this->_BIFF_version == 0x0600) {
-        $cch     = strlen($str);         // Length of footer string
+            $encoding = 0x0;                  // TODO: Unicode support
+            $length   = 3 + $cch;             // Bytes to follow
+        } else {
+            $length  = 1 + $cch;
         $length  = 1 + $cch;             // Bytes to follow
+        $header    = pack("vv", $record, $length);
+        if ($this->_BIFF_version == 0x0600) {
             $data      = pack("vC",  $cch, $encoding);
+        } else {
-        $header    = pack("vv", $record, $length);
+            $data      = pack("C",  $cch);
         $data      = pack("C",  $cch);
-        $this->_append($header.$data.$str);
+        $this->_prepend($header . $data . $str);
+    }
         $fHCenter = $this->_hcenter;     // Horizontal centering
         $header    = pack("vv", $record, $length);
         $data      = pack("v",  $fHCenter);
-        $this->_append($header.$data);
+        $this->_prepend($header.$data);
+    }
         $fVCenter = $this->_vcenter;     // Horizontal centering
         $header    = pack("vv", $record, $length);
         $data      = pack("v",  $fVCenter);
-        $this->_append($header.$data);
+        $this->_prepend($header . $data);
+    }
         $margin  = $this->_margin_left;       // Margin in inches
         $header    = pack("vv",  $record, $length);
-        $data      = pack("d",   $margin);
-        if ($this->_byte_order) // if it's Big Endian
+        $data      = pack("d",   $margin);
         if ($this->_byte_order) { // if it's Big Endian
             $data = strrev($data);
+        }
-        $this->_append($header.$data);
+        $this->_prepend($header . $data);
+    }
         $margin  = $this->_margin_right;      // Margin in inches
         $header    = pack("vv",  $record, $length);
-        $data      = pack("d",   $margin);
-        if ($this->_byte_order) // if it's Big Endian
+        $data      = pack("d",   $margin);
         if ($this->_byte_order) { // if it's Big Endian
             $data = strrev($data);
+        }
-        $this->_append($header.$data);
+        $this->_prepend($header . $data);
+    }
         $margin  = $this->_margin_top;        // Margin in inches
         $header    = pack("vv",  $record, $length);
-        $data      = pack("d",   $margin);
-        if ($this->_byte_order) // if it's Big Endian
+        $data      = pack("d",   $margin);
         if ($this->_byte_order) { // if it's Big Endian
             $data = strrev($data);
+        }
-        $this->_append($header.$data);
+        $this->_prepend($header . $data);
+    }
         $margin  = $this->_margin_bottom;     // Margin in inches
         $header    = pack("vv",  $record, $length);
-        $data      = pack("d",   $margin);
-        if ($this->_byte_order) // if it's Big Endian
+        $data      = pack("d",   $margin);
         if ($this->_byte_order) { // if it's Big Endian
             $data = strrev($data);
+        }
-        $this->_append($header.$data);
+        $this->_prepend($header . $data);
+    }
         $data        = pack("v",   $fGridSet);
-        $this->_prepend($header.$data);
+        $this->_prepend($header . $data);
+    }
+    /**
+    * Write the GUTS BIFF record. This is used to configure the gutter margins
+    * where Excel outline symbols are displayed. The visibility of the gutters is
+    * controlled by a flag in WSBOOL.
+    *
+    * @see _storeWsbool()
+    * @access private
+    */
+    function _storeGuts()
+    {
+        $record      = 0x0080;   // Record identifier
+        $length      = 0x0008;   // Bytes to follow
+        $dxRwGut     = 0x0000;   // Size of row gutter
+        $dxColGut    = 0x0000;   // Size of col gutter
+        $row_level   = $this->_outline_row_level;
+        $col_level   = 0;
+        // Calculate the maximum column outline level. The equivalent calculation
+        // for the row outline level is carried out in setRow().
+        $colcount = count($this->_colinfo);
+        for ($i = 0; $i < $colcount; $i++) {
+           // Skip cols without outline level info.
+           if (count($this->_colinfo[$i]) >= 6) {
+              $col_level = max($this->_colinfo[$i][5], $col_level);
+           }
+        }
+        // Set the limits for the outline levels (0 <= x <= 7).
+        $col_level = max(0, min($col_level, 7));
+        // The displayed level is one greater than the max outline levels
+        if ($row_level) {
+            $row_level++;
+        }
+        if ($col_level) {
+            $col_level++;
+        }
+        $header = pack("vv",   $record, $length);
+        $data   = pack("vvvv", $dxRwGut, $dxColGut, $row_level, $col_level);
+        $this->_prepend($header.$data);
+    }
     /**
     * Write the WSBOOL BIFF record, mainly for fit-to-page. Used in conjunction
     * with the SETUP record.
+    *
     * @access private
     */
     function _storeWsbool()
+    {
         $record      = 0x0081;   // Record identifier
+        $length      = 0x0002;   // Bytes to follow
-        $length      = 0x0002;   // Bytes to follow
+        $grbit       = 0x0000;
         // The only option that is of interest is the flag for fit to page. So we
         // set all the options in one go.
         //
-        if ($this->_fit_page) {
-            $grbit = 0x05c1;
+        /*if ($this->_fit_page) {
             $grbit = 0x05c1;
+        } else {
+            $grbit = 0x04c1;
+        }*/
+        // Set the option flags
+        $grbit |= 0x0001;                           // Auto page breaks visible
+        if ($this->_outline_style) {
+            $grbit |= 0x0020; // Auto outline styles
+        }
+        if ($this->_outline_below) {
+            $grbit |= 0x0040; // Outline summary below
+        }
+        if ($this->_outline_right) {
+            $grbit |= 0x0080; // Outline summary right
+        }
+        if ($this->_fit_page) {
+            $grbit |= 0x0100; // Page setup fit to page
+        }
-        else {
+        if ($this->_outline_on) {
-            $grbit = 0x04c1;
+            $grbit |= 0x0400; // Outline symbols displayed
+        }
-        $header      = pack("vv", $record, $length);
+        $header = pack("vv", $record, $length);
-        $data        = pack("v",  $grbit);
-        $this->_prepend($header.$data);
+        $data   = pack("v",  $grbit);
         $this->_prepend($header . $data);
+    }
     /**
             array_shift($breaks);
+        }
         $record  = 0x001b;               // Record identifier
+        $cbrk    = count($breaks);       // Number of page breaks
+        if ($this->_BIFF_version == 0x0600) {
+            $length  = 2 + 6*$cbrk;      // Bytes to follow
-        $cbrk    = count($breaks);       // Number of page breaks
+        } else {
+            $length  = 2 + 2*$cbrk;      // Bytes to follow
         $length  = ($cbrk + 1) * 2;      // Bytes to follow
         $header  = pack("vv", $record, $length);
         $data    = pack("v",  $cbrk);
+        // Append each page break
+        foreach ($breaks as $break) {
             if ($this->_BIFF_version == 0x0600) {
-        // Append each page break
+                $data .= pack("vvv", $break, 0x0000, 0x00ff);
+            } else {
-        foreach($breaks as $break) {
+                $data .= pack("v", $break);
             $data .= pack("v", $break);
             array_shift($breaks);
+        }
         $record  = 0x001a;               // Record identifier
+        $cbrk    = count($breaks);       // Number of page breaks
+        if ($this->_BIFF_version == 0x0600) {
+            $length  = 2 + 6*$cbrk;      // Bytes to follow
-        $cbrk    = count($breaks);       // Number of page breaks
+        } else {
+            $length  = 2 + 2*$cbrk;      // Bytes to follow
         $length  = ($cbrk + 1) * 2;      // Bytes to follow
         $header  = pack("vv",  $record, $length);
         $data    = pack("v",   $cbrk);
+        // Append each page break
+        foreach ($breaks as $break) {
             if ($this->_BIFF_version == 0x0600) {
-        // Append each page break
+                $data .= pack("vvv", $break, 0x0000, 0xffff);
+            } else {
-        foreach ($breaks as $break) {
+                $data .= pack("v", $break);
             $data .= pack("v", $break);
+        }
     * @access private
     */
     function _storePassword()
+    {
         // Exit unless sheet protection and password have been specified
-        if (($this->_protect == 0) or (!isset($this->_password))) {
+        if (($this->_protect == 0) || (!isset($this->_password))) {
             return;
+        }
         $record      = 0x0013;               // Record identifier
     * @param integer $scale_y The vertical scale
     */
     function insertBitmap($row, $col, $bitmap, $x = 0, $y = 0, $scale_x = 1, $scale_y = 1)
+    {
         $bitmap_array = $this->_processBitmap($bitmap);
-        if ($this->isError($bitmap_array))
+        if ($this->isError($bitmap_array)) {
-        {
             $this->writeString($row, $col, $bitmap_array->getMessage());
             return;
+        }
         list($width, $height, $size, $data) = $bitmap_array; //$this->_processBitmap($bitmap);
         // Initialise end cell to the same as the start cell
         $col_end    = $col_start;  // Col containing lower right corner of object
         $row_end    = $row_start;  // Row containing bottom right corner of object
         // Zero the specified offset if greater than the cell dimensions
-        if ($x1 >= $this->_sizeCol($col_start))
         if ($x1 >= $this->_sizeCol($col_start)) {
             $x1 = 0;
         }
-        if ($y1 >= $this->_sizeRow($row_start))
         if ($y1 >= $this->_sizeRow($row_start)) {
             $y1 = 0;
+        }
+        }
         // Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
         // with zero eight or width.
         //
-        if ($this->_sizeCol($col_start) == 0)
+        if ($this->_sizeCol($col_start) == 0) {
+            return;
-            return;
+        }
-        if ($this->_sizeCol($col_end)   == 0)
+        if ($this->_sizeCol($col_end)   == 0) {
+            return;
-            return;
+        }
-        if ($this->_sizeRow($row_start) == 0)
+        if ($this->_sizeRow($row_start) == 0) {
+            return;
-            return;
+        }
-        if ($this->_sizeRow($row_end)   == 0)
+        if ($this->_sizeRow($row_end)   == 0) {
+            return;
             return;
         // Convert the pixel values to the percentage value expected by Excel
         $x1 = $x1     / $this->_sizeCol($col_start)   * 1024;
         $y1 = $y1     / $this->_sizeRow($row_start)   *  256;
         $x2 = $width  / $this->_sizeCol($col_end)     * 1024; // Distance to right side of object
         $y2 = $height / $this->_sizeRow($row_end)     *  256; // Distance to bottom of object
-        $this->_storeObjPicture( $col_start, $x1,
+        $this->_storeObjPicture($col_start, $x1,
-                                  $row_start, $y1,
-                                  $col_end, $x2,
+                                 $row_start, $y1,
-                                  $row_end, $y2
+                                 $col_end, $x2,
-                                );
+                                 $row_end, $y2);
+    }
+    {
         // Look up the cell value to see if it has been changed
         if (isset($this->col_sizes[$col])) {
             if ($this->col_sizes[$col] == 0) {
                 return(0);
-            }
-            else {
+            } else {
                 return(floor(7 * $this->col_sizes[$col] + 5));
+            }
-        }
-        else {
+        } else {
             return(64);
+        }
+    }
     * @return integer The width in pixels
     */
     function _sizeRow($row)
+    {
         // Look up the cell value to see if it has been changed
-        if (isset($this->row_sizes[$row])) {
+        if (isset($this->_row_sizes[$row])) {
-            if ($this->row_sizes[$row] == 0) {
+            if ($this->_row_sizes[$row] == 0) {
                 return(0);
+            } else {
+                return(floor(4/3 * $this->_row_sizes[$row]));
+            }
-            else {
-                return(floor(4/3 * $this->row_sizes[$row]));
-            }
-        }
-        else {
+        } else {
             return(17);
+        }
+    }
     function _processBitmap($bitmap)
+    {
         // Open file.
         $bmp_fd = @fopen($bitmap,"rb");
         if (!$bmp_fd) {
-            return($this->raiseError("Couldn't import $bitmap"));
+            $this->raiseError("Couldn't import $bitmap");
+        }
         // Slurp the file into a string.
         $data = fread($bmp_fd, filesize($bitmap));
         // Check that the file is big enough to be a bitmap.
         if (strlen($data) <= 0x36) {
-            return($this->raiseError("$bitmap doesn't contain enough data.\n"));
+            $this->raiseError("$bitmap doesn't contain enough data.\n");
         }
         // The first 2 bytes are used to identify the bitmap.
-        $identity = unpack("A2", $data);
+        $identity = unpack("A2ident", $data);
-        if ($identity[''] != "BM") {
+        if ($identity['ident'] != "BM") {
-            return($this->raiseError("$bitmap doesn't appear to be a valid bitmap image.\n"));
+            $this->raiseError("$bitmap doesn't appear to be a valid bitmap image.\n");
+        }
         // Remove bitmap data: ID.
         $data = substr($data, 2);
         // Read and remove the bitmap size. This is more reliable than reading
         // the data size at offset 0x22.
         //
-        $size_array   = unpack("V", substr($data, 0, 4));
+        $size_array   = unpack("Vsa", substr($data, 0, 4));
         $width_and_height = unpack("V2", substr($data, 0, 8));
         $width  = $width_and_height[1];
         $height = $width_and_height[2];
         $data   = substr($data, 8);
         if ($width > 0xFFFF) {
-            return($this->raiseError("$bitmap: largest image width supported is 65k.\n"));
+            $this->raiseError("$bitmap: largest image width supported is 65k.\n");
+        }
         if ($height > 0xFFFF) {
-            return($this->raiseError("$bitmap: largest image height supported is 65k.\n"));
+            $this->raiseError("$bitmap: largest image height supported is 65k.\n");
+        }
         // Read and remove the bitmap planes and bpp data. Verify them.
         $planes_and_bitcount = unpack("v2", substr($data, 0, 4));
         $data = substr($data, 4);
         if ($planes_and_bitcount[2] != 24) { // Bitcount
-            return($this->raiseError("$bitmap isn't a 24bit true color bitmap.\n"));
+            $this->raiseError("$bitmap isn't a 24bit true color bitmap.\n");
+        }
         if ($planes_and_bitcount[1] != 1) {
-            return($this->raiseError("$bitmap: only 1 plane nupported in bitmap image.\n"));
+            $this->raiseError("$bitmap: only 1 plane supported in bitmap image.\n");
+        }
         // Read and remove the bitmap compression. Verify compression.
-        $compression = unpack("V", substr($data, 0, 4));
+        $compression = unpack("Vcomp", substr($data, 0, 4));
         $data = substr($data, 4);
         //$compression = 0;
-        if ($compression[""] != 0) {
+        if ($compression['comp'] != 0) {
-            return($this->raiseError("$bitmap: compression not supported in bitmap image.\n"));
+            $this->raiseError("$bitmap: compression not supported in bitmap image.\n");
         $header      = pack("vv", $record, $length);
         $data        = pack("vv", $this->_zoom, 100);
-        $this->_append($header.$data);
+        $this->_append($header . $data);
+    }
+    /**
+    * FIXME: add comments
+    */
+    function setValidation($row1, $col1, $row2, $col2, &$validator)
+    {
+        $this->_dv[] = $validator->_getData() .
+                       pack("vvvvv", 1, $row1, $row2, $col1, $col2);
+    }
+    /**
+    * Store the DVAL and DV records.
+    *
+    * @access private
+    */
+    function _storeDataValidity()
+    {
+        $record      = 0x01b2;      // Record identifier
+        $length      = 0x0012;      // Bytes to follow
+        $grbit       = 0x0002;      // Prompt box at cell, no cached validity data at DV records
+        $horPos      = 0x00000000;  // Horizontal position of prompt box, if fixed position
+        $verPos      = 0x00000000;  // Vertical position of prompt box, if fixed position
+        $objId       = 0xffffffff;  // Object identifier of drop down arrow object, or -1 if not visible
+        $header      = pack('vv', $record, $length);
+        $data        = pack('vVVVV', $grbit, $horPos, $verPos, $objId,
+                                     count($this->_dv));
+        $this->_append($header.$data);
+        $record = 0x01be;              // Record identifier
+        foreach ($this->_dv as $dv) {
+            $length = strlen($dv);      // Bytes to follow
+            $header = pack("vv", $record, $length);
+            $this->_append($header . $dv);
+        }
+    }
+}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/jrest/lib/Spreadsheet/Excel/Writer/Worksheet.php @ 2403 – Rev 996 → 1604