PHPExcel_Cell
[ class tree: PHPExcel_Cell ] [ index: PHPExcel_Cell ] [ all elements ]

Source for file Cell.php

Documentation is available at Cell.php

  1. <?php
  2. /**
  3.  * PHPExcel
  4.  *
  5.  * Copyright (c) 2006 - 2010 PHPExcel
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with this library; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20.  *
  21.  * @category    PHPExcel
  22.  * @package        PHPExcel_Cell
  23.  * @copyright    Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
  24.  * @license        http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  25.  * @version        1.7.2, 2010-01-11
  26.  */
  27.  
  28.  
  29. /** PHPExcel root directory */
  30. if (!defined('PHPEXCEL_ROOT')) {
  31.     /**
  32.      * @ignore
  33.      */
  34.     define('PHPEXCEL_ROOT'dirname(__FILE__'/../');
  35. }
  36.  
  37. /** PHPExcel_Cell_DataType */
  38. require_once PHPEXCEL_ROOT 'PHPExcel/Cell/DataType.php';
  39.  
  40. /** PHPExcel_Cell_DataValidation */
  41. require_once PHPEXCEL_ROOT 'PHPExcel/Cell/DataValidation.php';
  42.  
  43. /** PHPExcel_Cell_Hyperlink */
  44. require_once PHPEXCEL_ROOT 'PHPExcel/Cell/Hyperlink.php';
  45.  
  46. /** PHPExcel_Worksheet */
  47. require_once PHPEXCEL_ROOT 'PHPExcel/Worksheet.php';
  48.  
  49. /** PHPExcel_Calculation */
  50. require_once PHPEXCEL_ROOT 'PHPExcel/Calculation.php';
  51.  
  52. /** PHPExcel_Cell_IValueBinder */
  53. require_once PHPEXCEL_ROOT 'PHPExcel/Cell/IValueBinder.php';
  54.  
  55. /** PHPExcel_Cell_DefaultValueBinder */
  56. require_once PHPEXCEL_ROOT 'PHPExcel/Cell/DefaultValueBinder.php';
  57.  
  58. /** PHPExcel_Shared_String */
  59. require_once PHPEXCEL_ROOT 'PHPExcel/Shared/String.php';
  60.  
  61.  
  62. /**
  63.  * PHPExcel_Cell
  64.  *
  65.  * @category   PHPExcel
  66.  * @package    PHPExcel_Cell
  67.  * @copyright  Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
  68.  */
  69. {
  70.     /**
  71.      * Value binder to use
  72.      *
  73.      * @var PHPExcel_Cell_IValueBinder 
  74.      */
  75.     private static $_valueBinder null;
  76.  
  77.     /**
  78.      * Column of the cell
  79.      *
  80.      * @var string 
  81.      */
  82.     private $_column;
  83.  
  84.     /**
  85.      * Row of the cell
  86.      *
  87.      * @var int 
  88.      */
  89.     private $_row;
  90.  
  91.     /**
  92.      * Value of the cell
  93.      *
  94.      * @var mixed 
  95.      */
  96.     private $_value;
  97.  
  98.     /**
  99.      * Calculated value of the cell (used for caching)
  100.      *
  101.      * @var mixed 
  102.      */
  103.     private $_calculatedValue = null;
  104.  
  105.     /**
  106.      * Type of the cell data
  107.      *
  108.      * @var string 
  109.      */
  110.     private $_dataType;
  111.  
  112.     /**
  113.      * Parent worksheet
  114.      *
  115.      * @var PHPExcel_Worksheet 
  116.      */
  117.     private $_parent;
  118.  
  119.     /**
  120.      * Index to cellXf
  121.      *
  122.      * @var int 
  123.      */
  124.     private $_xfIndex;
  125.  
  126.     /**
  127.      * Create a new Cell
  128.      *
  129.      * @param     string                 $pColumn 
  130.      * @param     int                 $pRow 
  131.      * @param     mixed                 $pValue 
  132.      * @param     string                 $pDataType 
  133.      * @param     PHPExcel_Worksheet    $pSheet 
  134.      * @throws    Exception
  135.      */
  136.     public function __construct($pColumn 'A'$pRow 1$pValue null$pDataType nullPHPExcel_Worksheet $pSheet null)
  137.     {
  138.         // Initialise cell coordinate
  139.         $this->_column = strtoupper($pColumn);
  140.         $this->_row = $pRow;
  141.  
  142.         // Initialise cell value
  143.         $this->_value = $pValue;
  144.  
  145.         // Set worksheet
  146.         $this->_parent = $pSheet;
  147.  
  148.         // Set datatype?
  149.         if (!is_null($pDataType)) {
  150.             $this->_dataType = $pDataType;
  151.         else {
  152.             if (!self::getValueBinder()->bindValue($this$pValue)) {
  153.                 throw new Exception("Value could not be bound to cell.");
  154.             }
  155.         }
  156.  
  157.         // set default index to cellXf
  158.         $this->_xfIndex = 0;
  159.     }
  160.  
  161.     /**
  162.      * Get cell coordinate column
  163.      *
  164.      * @return string 
  165.      */
  166.     public function getColumn()
  167.     {
  168.         return $this->_column;
  169.     }
  170.  
  171.     /**
  172.      * Get cell coordinate row
  173.      *
  174.      * @return int 
  175.      */
  176.     public function getRow()
  177.     {
  178.         return $this->_row;
  179.     }
  180.  
  181.     /**
  182.      * Get cell coordinate
  183.      *
  184.      * @return string 
  185.      */
  186.     public function getCoordinate()
  187.     {
  188.         return $this->_column . $this->_row;
  189.     }
  190.  
  191.     /**
  192.      * Get cell value
  193.      *
  194.      * @return mixed 
  195.      */
  196.     public function getValue()
  197.     {
  198.         return $this->_value;
  199.     }
  200.  
  201.     /**
  202.      * Set cell value
  203.      *
  204.      * This clears the cell formula.
  205.      *
  206.      * @param mixed     $pValue                    Value
  207.      * @return PHPExcel_Cell 
  208.      */
  209.     public function setValue($pValue null)
  210.     {
  211.         if (!self::getValueBinder()->bindValue($this$pValue)) {
  212.             throw new Exception("Value could not be bound to cell.");
  213.         }
  214.         return $this;
  215.     }
  216.  
  217.     /**
  218.      * Set cell value (with explicit data type given)
  219.      *
  220.      * @param mixed     $pValue            Value
  221.      * @param string    $pDataType        Explicit data type
  222.      * @return PHPExcel_Cell 
  223.      * @throws Exception
  224.      */
  225.     public function setValueExplicit($pValue null$pDataType PHPExcel_Cell_DataType::TYPE_STRING)
  226.     {
  227.         // set the value according to data type
  228.         switch ($pDataType{
  229.             case PHPExcel_Cell_DataType::TYPE_STRING:
  230.             case PHPExcel_Cell_DataType::TYPE_NULL:
  231.             case PHPExcel_Cell_DataType::TYPE_INLINE:
  232.                 $this->_value = PHPExcel_Cell_DataType::checkString($pValue);
  233.                 break;
  234.  
  235.             case PHPExcel_Cell_DataType::TYPE_NUMERIC:
  236.                 $this->_value = (float)$pValue;
  237.                 break;
  238.  
  239.             case PHPExcel_Cell_DataType::TYPE_FORMULA:
  240.                 $this->_value = (string)$pValue;
  241.                 break;
  242.  
  243.             case PHPExcel_Cell_DataType::TYPE_BOOL:
  244.                 $this->_value = (bool)$pValue;
  245.                 break;
  246.  
  247.             case PHPExcel_Cell_DataType::TYPE_ERROR:
  248.                 $this->_value = PHPExcel_Cell_DataType::checkErrorCode($pValue);
  249.                 break;
  250.  
  251.             default:
  252.                 throw new Exception('Invalid datatype: ' $pDataType);
  253.                 break;
  254.         }
  255.  
  256.         // set the datatype
  257.         $this->_dataType = $pDataType;
  258.         return $this;
  259.     }
  260.  
  261.     /**
  262.      * Get caluclated cell value
  263.      *
  264.      * @return mixed 
  265.      */
  266.     public function getCalculatedValue($resetLog=true)
  267.     {
  268. //        echo 'Cell '.$this->getCoordinate().' value is a '.$this->_dataType.' with a value of '.$this->getValue().'<br />';
  269.         if (!is_null($this->_calculatedValue&& $this->_dataType == PHPExcel_Cell_DataType::TYPE_FORMULA{
  270.             try {
  271. //                echo 'Cell value for '.$this->getCoordinate().' is a formula: Calculating value<br />';
  272.                 $result PHPExcel_Calculation::getInstance()->calculateCellValue($this,$resetLog);
  273.             catch Exception $ex {
  274. //                echo 'Calculation Exception: '.$ex->getMessage().'<br />';
  275.                 $result '#N/A';
  276.             }
  277.  
  278.             if ((is_string($result)) && ($result == '#Not Yet Implemented')) {
  279. //                echo 'Returning fallback value of '.$this->_calculatedValue.' for cell '.$this->getCoordinate().'<br />';
  280.                 return $this->_calculatedValue// Fallback if calculation engine does not support the formula.
  281.             else {
  282. //                echo 'Returning calculated value of '.$result.' for cell '.$this->getCoordinate().'<br />';
  283.                 return $result;
  284.             }
  285.         }
  286.  
  287.         if (is_null($this->_value)) {
  288. //            echo 'Cell '.$this->getCoordinate().' has no value, formula or otherwise<br />';
  289.             return null;
  290.         else if ($this->_dataType != PHPExcel_Cell_DataType::TYPE_FORMULA{
  291. //            echo 'Cell value for '.$this->getCoordinate().' is not a formula: Returning data value of '.$this->_value.'<br />';
  292.             return $this->_value;
  293.         else {
  294. //            echo 'Cell value is a formula: Calculating value<br />';
  295.             return PHPExcel_Calculation::getInstance()->calculateCellValue($this,$resetLog);
  296.         }
  297.     }
  298.  
  299.     /**
  300.      * Set calculated value (used for caching)
  301.      *
  302.      * @param mixed $pValue    Value
  303.      * @return PHPExcel_Cell 
  304.      */
  305.     public function setCalculatedValue($pValue null)
  306.     {
  307.         if (!is_null($pValue)) {
  308.             $this->_calculatedValue = $pValue;
  309.         }
  310.         return $this;
  311.     }
  312.  
  313.     /**
  314.      * Get old calculated value (cached)
  315.      *
  316.      * @return mixed 
  317.      */
  318.     public function getOldCalculatedValue()
  319.     {
  320.         return $this->_calculatedValue;
  321.     }
  322.  
  323.     /**
  324.      * Get cell data type
  325.      *
  326.      * @return string 
  327.      */
  328.     public function getDataType()
  329.     {
  330.         return $this->_dataType;
  331.     }
  332.  
  333.     /**
  334.      * Set cell data type
  335.      *
  336.      * @param string $pDataType 
  337.      * @return PHPExcel_Cell 
  338.      */
  339.     public function setDataType($pDataType PHPExcel_Cell_DataType::TYPE_STRING)
  340.     {
  341.         $this->_dataType = $pDataType;
  342.         return $this;
  343.     }
  344.  
  345.     /**
  346.      * Has Data validation?
  347.      *
  348.      * @return boolean 
  349.      */
  350.     public function hasDataValidation()
  351.     {
  352.         if (!isset($this->_parent)) {
  353.             throw new Exception('Cannot check for data validation when cell is not bound to a worksheet');
  354.         }
  355.  
  356.         return $this->_parent->dataValidationExists($this->getCoordinate());
  357.     }
  358.  
  359.     /**
  360.      * Get Data validation
  361.      *
  362.      * @return PHPExcel_Cell_DataValidation 
  363.      */
  364.     public function getDataValidation()
  365.     {
  366.         if (!isset($this->_parent)) {
  367.             throw new Exception('Cannot get data validation for cell that is not bound to a worksheet');
  368.         }
  369.  
  370.         $dataValidation $this->_parent->getDataValidation($this->getCoordinate());
  371.         return $dataValidation;
  372.     }
  373.  
  374.     /**
  375.      * Set Data validation
  376.      *
  377.      * @param     PHPExcel_Cell_DataValidation    $pDataValidation 
  378.      * @throws     Exception
  379.      * @return PHPExcel_Cell 
  380.      */
  381.     public function setDataValidation(PHPExcel_Cell_DataValidation $pDataValidation null)
  382.     {
  383.         if (!isset($this->_parent)) {
  384.             throw new Exception('Cannot set data validation for cell that is not bound to a worksheet');
  385.         }
  386.  
  387.         $this->_parent->setDataValidation($this->getCoordinate()$pDataValidation);
  388.         return $this;
  389.     }
  390.  
  391.     /**
  392.      * Has Hyperlink
  393.      *
  394.      * @return boolean 
  395.      */
  396.     public function hasHyperlink()
  397.     {
  398.         if (!isset($this->_parent)) {
  399.             throw new Exception('Cannot check for hyperlink when cell is not bound to a worksheet');
  400.         }
  401.  
  402.         return $this->_parent->hyperlinkExists($this->getCoordinate());
  403.     }
  404.  
  405.     /**
  406.      * Get Hyperlink
  407.      *
  408.      * @throws Exception
  409.      * @return PHPExcel_Cell_Hyperlink 
  410.      */
  411.     public function getHyperlink()
  412.     {
  413.         if (!isset($this->_parent)) {
  414.             throw new Exception('Cannot get hyperlink for cell that is not bound to a worksheet');
  415.         }
  416.  
  417.         $hyperlink $this->_parent->getHyperlink($this->getCoordinate());
  418.         return $hyperlink;
  419.     }
  420.  
  421.     /**
  422.      * Set Hyperlink
  423.      *
  424.      * @param     PHPExcel_Cell_Hyperlink    $pHyperlink 
  425.      * @throws     Exception
  426.      * @return PHPExcel_Cell 
  427.      */
  428.     public function setHyperlink(PHPExcel_Cell_Hyperlink $pHyperlink null)
  429.     {
  430.         if (!isset($this->_parent)) {
  431.             throw new Exception('Cannot set hyperlink for cell that is not bound to a worksheet');
  432.         }
  433.  
  434.         $this->_parent->setHyperlink($this->getCoordinate()$pHyperlink);
  435.         return $this;
  436.     }
  437.  
  438.     /**
  439.      * Get parent
  440.      *
  441.      * @return PHPExcel_Worksheet 
  442.      */
  443.     public function getParent({
  444.         return $this->_parent;
  445.     }
  446.  
  447.     /**
  448.      * Re-bind parent
  449.      *
  450.      * @param PHPExcel_Worksheet $parent 
  451.      * @return PHPExcel_Cell 
  452.      */
  453.     public function rebindParent(PHPExcel_Worksheet $parent{
  454.         $this->_parent = $parent;
  455.         return $this;
  456.     }
  457.  
  458.     /**
  459.      * Is cell in a specific range?
  460.      *
  461.      * @param     string     $pRange        Cell range (e.g. A1:A1)
  462.      * @return     boolean 
  463.      */
  464.     public function isInRange($pRange 'A1:A1')
  465.     {
  466.         // Uppercase coordinate
  467.         $pRange strtoupper($pRange);
  468.  
  469.            // Extract range
  470.            $rangeA     '';
  471.            $rangeB     '';
  472.            if (strpos($pRange':'=== false{
  473.                $rangeA $pRange;
  474.                $rangeB $pRange;
  475.            else {
  476.                list($rangeA$rangeBexplode(':'$pRange);
  477.            }
  478.  
  479.            // Calculate range outer borders
  480.            $rangeStart PHPExcel_Cell::coordinateFromString($rangeA);
  481.            $rangeEnd     PHPExcel_Cell::coordinateFromString($rangeB);
  482.  
  483.            // Translate column into index
  484.            $rangeStart[0]    PHPExcel_Cell::columnIndexFromString($rangeStart[0]1;
  485.            $rangeEnd[0]    PHPExcel_Cell::columnIndexFromString($rangeEnd[0]1;
  486.  
  487.            // Translate properties
  488.         $myColumn        PHPExcel_Cell::columnIndexFromString($this->getColumn()) 1;
  489.         $myRow            $this->getRow();
  490.  
  491.         // Verify if cell is in range
  492.         return (
  493.                 ($rangeStart[0<= $myColumn && $rangeEnd[0>= $myColumn&&
  494.                 ($rangeStart[1<= $myRow && $rangeEnd[1>= $myRow)
  495.         );
  496.     }
  497.  
  498.     /**
  499.      * Coordinate from string
  500.      *
  501.      * @param     string     $pCoordinateString 
  502.      * @return     array     Array containing column and row (indexes 0 and 1)
  503.      * @throws    Exception
  504.      */
  505.     public static function coordinateFromString($pCoordinateString 'A1')
  506.     {
  507.         if (strpos($pCoordinateString,':'!== false{
  508.             throw new Exception('Cell coordinate string can not be a range of cells.');
  509.  
  510.         else if ($pCoordinateString == ''{
  511.             throw new Exception('Cell coordinate can not be zero-length string.');
  512.  
  513.         else if (preg_match("/([$]?[A-Z]+)([$]?\d+)/"$pCoordinateString$matches)) {
  514.             list($column$row$matches;
  515.             return array($column$row);
  516.  
  517.         else {
  518.             throw new Exception('Invalid cell coordinate.');
  519.  
  520.         }
  521.     }
  522.  
  523.     /**
  524.      * Make string coordinate absolute
  525.      *
  526.      * @param     string     $pCoordinateString 
  527.      * @return     string    Absolute coordinate
  528.      * @throws    Exception
  529.      */
  530.     public static function absoluteCoordinate($pCoordinateString 'A1')
  531.     {
  532.         if (strpos($pCoordinateString,':'=== false && strpos($pCoordinateString,','=== false{
  533.             // Return value
  534.             $returnValue '';
  535.  
  536.             // Create absolute coordinate
  537.             list($column$rowPHPExcel_Cell::coordinateFromString($pCoordinateString);
  538.             $returnValue '$' $column '$' $row;
  539.  
  540.             // Return
  541.             return $returnValue;
  542.         else {
  543.             throw new Exception("Coordinate string should not be a cell range.");
  544.         }
  545.     }
  546.  
  547.     /**
  548.      * Split range into coordinate strings
  549.      *
  550.      * @param     string     $pRange 
  551.      * @return     array    Array containg one or more arrays containing one or two coordinate strings
  552.      */
  553.     public static function splitRange($pRange 'A1:A1')
  554.     {
  555.         $exploded explode(','$pRange);
  556.         for ($i 0$i count($exploded)++$i{
  557.             $exploded[$iexplode(':'$exploded[$i]);
  558.         }
  559.         return $exploded;
  560.     }
  561.  
  562.     /**
  563.      * Build range from coordinate strings
  564.      *
  565.      * @param     array    $pRange    Array containg one or more arrays containing one or two coordinate strings
  566.      * @return  string    String representation of $pRange
  567.      * @throws    Exception
  568.      */
  569.     public static function buildRange($pRange)
  570.     {
  571.         // Verify range
  572.         if (!is_array($pRange|| count($pRange== || !is_array($pRange[0])) {
  573.             throw new Exception('Range does not contain any information.');
  574.         }
  575.  
  576.         // Build range
  577.         $imploded array();
  578.         for ($i 0$i count($pRange)++$i{
  579.             $pRange[$iimplode(':'$pRange[$i]);
  580.         }
  581.         $imploded implode(','$pRange);
  582.  
  583.         return $imploded;
  584.     }
  585.  
  586.     /**
  587.      * Calculate range dimension
  588.      *
  589.      * @param     string     $pRange        Cell range (e.g. A1:A1)
  590.      * @return     array    Range dimension (width, height)
  591.      */
  592.     public static function rangeDimension($pRange 'A1:A1')
  593.     {
  594.         // Uppercase coordinate
  595.         $pRange strtoupper($pRange);
  596.  
  597.            // Extract range
  598.            $rangeA     '';
  599.            $rangeB     '';
  600.            if (strpos($pRange':'=== false{
  601.                $rangeA $pRange;
  602.                $rangeB $pRange;
  603.            else {
  604.                list($rangeA$rangeBexplode(':'$pRange);
  605.            }
  606.  
  607.            // Calculate range outer borders
  608.            $rangeStart PHPExcel_Cell::coordinateFromString($rangeA);
  609.            $rangeEnd     PHPExcel_Cell::coordinateFromString($rangeB);
  610.  
  611.            // Translate column into index
  612.            $rangeStart[0]    PHPExcel_Cell::columnIndexFromString($rangeStart[0]);
  613.            $rangeEnd[0]    PHPExcel_Cell::columnIndexFromString($rangeEnd[0]);
  614.  
  615.            return array( ($rangeEnd[0$rangeStart[01)($rangeEnd[1$rangeStart[11) );
  616.     }
  617.  
  618.     /**
  619.      * Column index from string
  620.      *
  621.      * @param     string $pString 
  622.      * @return     int Column index (base 1 !!!)
  623.      * @throws     Exception
  624.      */
  625.     public static function columnIndexFromString($pString 'A')
  626.     {
  627.         // Convert to uppercase
  628.         $pString strtoupper($pString);
  629.  
  630.         $strLen strlen($pString);
  631.         // Convert column to integer
  632.         if ($strLen == 1{
  633.             return (ord($pString{0}64);
  634.         elseif ($strLen == 2{
  635.             return $result (((ord($pString{0}65)) 26(ord($pString{1}64);
  636.         elseif ($strLen == 3{
  637.             return (((ord($pString{0}65)) 676(((ord($pString{1}65)) 26(ord($pString{2}64);
  638.         else {
  639.             throw new Exception("Column string index can not be " ($strLen != "longer than 3 characters" "empty"".");
  640.         }
  641.     }
  642.  
  643.     /**
  644.      * String from columnindex
  645.      *
  646.      * @param int $pColumnIndex Column index (base 0 !!!)
  647.      * @return string 
  648.      */
  649.     public static function stringFromColumnIndex($pColumnIndex 0)
  650.     {
  651.         // Determine column string
  652.         if ($pColumnIndex 26{
  653.             return chr(65 $pColumnIndex);
  654.         }
  655.            return PHPExcel_Cell::stringFromColumnIndex((int)($pColumnIndex 26-1).chr(65 $pColumnIndex%26;
  656.     }
  657.  
  658.     /**
  659.      * Extract all cell references in range
  660.      *
  661.      * @param     string     $pRange        Range (e.g. A1 or A1:A10 or A1:A10 A100:A1000)
  662.      * @return     array    Array containing single cell references
  663.      */
  664.     public static function extractAllCellReferencesInRange($pRange 'A1'{
  665.         // Returnvalue
  666.         $returnValue array();
  667.  
  668.         // Explode spaces
  669.         $aExplodeSpaces explode(' 'str_replace('$'''strtoupper($pRange)));
  670.         foreach ($aExplodeSpaces as $explodedSpaces{
  671.             // Single cell?
  672.             if (strpos($explodedSpaces,':'=== false && strpos($explodedSpaces,','=== false{
  673.                 $col 'A';
  674.                 $row 1;
  675.                 list($col$rowPHPExcel_Cell::coordinateFromString($explodedSpaces);
  676.  
  677.                 if (strlen($col<= 2{
  678.                     $returnValue[$explodedSpaces;
  679.                 }
  680.  
  681.                 continue;
  682.             }
  683.  
  684.             // Range...
  685.             $range PHPExcel_Cell::splitRange($explodedSpaces);
  686.             for ($i 0$i count($range)++$i{
  687.                 // Single cell?
  688.                 if (count($range[$i]== 1{
  689.                     $col 'A';
  690.                     $row 1;
  691.                     list($col$rowPHPExcel_Cell::coordinateFromString($range[$i]);
  692.  
  693.                     if (strlen($col<= 2{
  694.                         $returnValue[$explodedSpaces;
  695.                     }
  696.                 }
  697.  
  698.                 // Range...
  699.                 $rangeStart        $rangeEnd        '';
  700.                 $startingCol    $startingRow    $endingCol    $endingRow    0;
  701.  
  702.                 list($rangeStart$rangeEnd)         $range[$i];
  703.                 list($startingCol$startingRow)    PHPExcel_Cell::coordinateFromString($rangeStart);
  704.                 list($endingCol$endingRow)          PHPExcel_Cell::coordinateFromString($rangeEnd);
  705.  
  706.                 // Conversions...
  707.                 $startingCol     PHPExcel_Cell::columnIndexFromString($startingCol);
  708.                 $endingCol         PHPExcel_Cell::columnIndexFromString($endingCol);
  709.  
  710.                 // Current data
  711.                 $currentCol     = --$startingCol;
  712.                 $currentRow     $startingRow;
  713.  
  714.                 // Loop cells
  715.                 while ($currentCol $endingCol{
  716.                     $loopColumn PHPExcel_Cell::stringFromColumnIndex($currentCol);
  717.                     while ($currentRow <= $endingRow{
  718.                         $returnValue[$loopColumn.$currentRow;
  719.                         ++$currentRow;
  720.                     }
  721.                     ++$currentCol;
  722.                     $currentRow $startingRow;
  723.                 }
  724.             }
  725.         }
  726.  
  727.         // Return value
  728.         return $returnValue;
  729.     }
  730.  
  731.     /**
  732.      * Compare 2 cells
  733.      *
  734.      * @param     PHPExcel_Cell    $a    Cell a
  735.      * @param     PHPExcel_Cell    $a    Cell b
  736.      * @return     int        Result of comparison (always -1 or 1, never zero!)
  737.      */
  738.     public static function compareCells(PHPExcel_Cell $aPHPExcel_Cell $b)
  739.     {
  740.         if ($a->_row $b->_row{
  741.             return -1;
  742.         elseif ($a->_row $b->_row{
  743.             return 1;
  744.         elseif (PHPExcel_Cell::columnIndexFromString($a->_columnPHPExcel_Cell::columnIndexFromString($b->_column)) {
  745.             return -1;
  746.         else {
  747.             return 1;
  748.         }
  749.     }
  750.  
  751.     /**
  752.      * Get value binder to use
  753.      *
  754.      * @return PHPExcel_Cell_IValueBinder 
  755.      */
  756.     public static function getValueBinder({
  757.         if (is_null(self::$_valueBinder)) {
  758.             self::$_valueBinder new PHPExcel_Cell_DefaultValueBinder();
  759.         }
  760.  
  761.         return self::$_valueBinder;
  762.     }
  763.  
  764.     /**
  765.      * Set value binder to use
  766.      *
  767.      * @param PHPExcel_Cell_IValueBinder $binder 
  768.      * @throws Exception
  769.      */
  770.     public static function setValueBinder(PHPExcel_Cell_IValueBinder $binder null{
  771.         if (is_null($binder)) {
  772.             throw new Exception("A PHPExcel_Cell_IValueBinder is required for PHPExcel to function correctly.");
  773.         }
  774.  
  775.         self::$_valueBinder $binder;
  776.     }
  777.  
  778.     /**
  779.      * Implement PHP __clone to create a deep clone, not just a shallow copy.
  780.      */
  781.     public function __clone({
  782.         $vars get_object_vars($this);
  783.         foreach ($vars as $key => $value{
  784.             if (is_object($value)) {
  785.                 $this->$key clone $value;
  786.             else {
  787.                 $this->$key $value;
  788.             }
  789.         }
  790.     }
  791.  
  792.     /**
  793.      * Get index to cellXf
  794.      *
  795.      * @return int 
  796.      */
  797.     public function getXfIndex()
  798.     {
  799.         return $this->_xfIndex;
  800.     }
  801.  
  802.     /**
  803.      * Set index to cellXf
  804.      *
  805.      * @param int $pValue 
  806.      * @return PHPExcel_Cell 
  807.      */
  808.     public function setXfIndex($pValue 0)
  809.     {
  810.         $this->_xfIndex = $pValue;
  811.         return $this;
  812.     }
  813.  
  814. }

Documentation generated on Mon, 11 Jan 2010 08:07:07 +0100 by phpDocumentor 1.4.1