PHP Cell::stringFromColumnIndex方法代码示例

 /**
  * Read ClientAnchor record. This record holds information about where the shape is anchored in worksheet
  */
 private function _readClientAnchor()
 {
     $length = $this->_GetInt4d($this->_data, $this->_pos + 4);
     $recordData = substr($this->_data, $this->_pos + 8, $length);
     // move stream pointer to next record
     $this->_pos += 8 + $length;
     // offset: 2; size: 2; upper-left corner column index (0-based)
     $c1 = $this->_GetInt2d($recordData, 2);
     // offset: 4; size: 2; upper-left corner horizontal offset in 1/1024 of column width
     $startOffsetX = $this->_GetInt2d($recordData, 4);
     // offset: 6; size: 2; upper-left corner row index (0-based)
     $r1 = $this->_GetInt2d($recordData, 6);
     // offset: 8; size: 2; upper-left corner vertical offset in 1/256 of row height
     $startOffsetY = $this->_GetInt2d($recordData, 8);
     // offset: 10; size: 2; bottom-right corner column index (0-based)
     $c2 = $this->_GetInt2d($recordData, 10);
     // offset: 12; size: 2; bottom-right corner horizontal offset in 1/1024 of column width
     $endOffsetX = $this->_GetInt2d($recordData, 12);
     // offset: 14; size: 2; bottom-right corner row index (0-based)
     $r2 = $this->_GetInt2d($recordData, 14);
     // offset: 16; size: 2; bottom-right corner vertical offset in 1/256 of row height
     $endOffsetY = $this->_GetInt2d($recordData, 16);
     // set the start coordinates
     $this->_object->setStartCoordinates(Cell::stringFromColumnIndex($c1) . ($r1 + 1));
     // set the start offsetX
     $this->_object->setStartOffsetX($startOffsetX);
     // set the start offsetY
     $this->_object->setStartOffsetY($startOffsetY);
     // set the end coordinates
     $this->_object->setEndCoordinates(Cell::stringFromColumnIndex($c2) . ($r2 + 1));
     // set the end offsetX
     $this->_object->setEndOffsetX($endOffsetX);
     // set the end offsetY
     $this->_object->setEndOffsetY($endOffsetY);
 }

//.........这里部分代码省略.........
                             }
                         }
                         if (isset($xmlSheet->sheetPr) && isset($xmlSheet->sheetPr->outlinePr)) {
                             if (isset($xmlSheet->sheetPr->outlinePr['summaryRight']) && $xmlSheet->sheetPr->outlinePr['summaryRight'] == false) {
                                 $docSheet->setShowSummaryRight(false);
                             } else {
                                 $docSheet->setShowSummaryRight(true);
                             }
                             if (isset($xmlSheet->sheetPr->outlinePr['summaryBelow']) && $xmlSheet->sheetPr->outlinePr['summaryBelow'] == false) {
                                 $docSheet->setShowSummaryBelow(false);
                             } else {
                                 $docSheet->setShowSummaryBelow(true);
                             }
                         }
                         if (isset($xmlSheet->sheetPr) && isset($xmlSheet->sheetPr->pageSetUpPr)) {
                             if (isset($xmlSheet->sheetPr->pageSetUpPr['fitToPage']) && $xmlSheet->sheetPr->pageSetUpPr['fitToPage'] == false) {
                                 $docSheet->getPageSetup()->setFitToPage(false);
                             } else {
                                 $docSheet->getPageSetup()->setFitToPage(true);
                             }
                         }
                         if (isset($xmlSheet->sheetFormatPr)) {
                             if (isset($xmlSheet->sheetFormatPr['customHeight']) && ((string) $xmlSheet->sheetFormatPr['customHeight'] == '1' || strtolower((string) $xmlSheet->sheetFormatPr['customHeight']) == 'true') && isset($xmlSheet->sheetFormatPr['defaultRowHeight'])) {
                                 $docSheet->getDefaultRowDimension()->setRowHeight((double) $xmlSheet->sheetFormatPr['defaultRowHeight']);
                             }
                             if (isset($xmlSheet->sheetFormatPr['defaultColWidth'])) {
                                 $docSheet->getDefaultColumnDimension()->setWidth((double) $xmlSheet->sheetFormatPr['defaultColWidth']);
                             }
                         }
                         if (isset($xmlSheet->cols) && !$this->_readDataOnly) {
                             foreach ($xmlSheet->cols->col as $col) {
                                 for ($i = intval($col["min"]) - 1; $i < intval($col["max"]); ++$i) {
                                     if ($col["style"] && !$this->_readDataOnly) {
                                         $docSheet->getColumnDimension(Cell::stringFromColumnIndex($i))->setXfIndex(intval($col["style"]));
                                     }
                                     if ($col["bestFit"]) {
                                         //$docSheet->getColumnDimension(Cell::stringFromColumnIndex($i))->setAutoSize(true);
                                     }
                                     if ($col["hidden"]) {
                                         $docSheet->getColumnDimension(Cell::stringFromColumnIndex($i))->setVisible(false);
                                     }
                                     if ($col["collapsed"]) {
                                         $docSheet->getColumnDimension(Cell::stringFromColumnIndex($i))->setCollapsed(true);
                                     }
                                     if ($col["outlineLevel"] > 0) {
                                         $docSheet->getColumnDimension(Cell::stringFromColumnIndex($i))->setOutlineLevel(intval($col["outlineLevel"]));
                                     }
                                     $docSheet->getColumnDimension(Cell::stringFromColumnIndex($i))->setWidth(floatval($col["width"]));
                                     if (intval($col["max"]) == 16384) {
                                         break;
                                     }
                                 }
                             }
                         }
                         if (isset($xmlSheet->printOptions) && !$this->_readDataOnly) {
                             if ($xmlSheet->printOptions['gridLinesSet'] == 'true' && $xmlSheet->printOptions['gridLinesSet'] == '1') {
                                 $docSheet->setShowGridlines(true);
                             }
                             if ($xmlSheet->printOptions['gridLines'] == 'true' || $xmlSheet->printOptions['gridLines'] == '1') {
                                 $docSheet->setPrintGridlines(true);
                             }
                             if ($xmlSheet->printOptions['horizontalCentered']) {
                                 $docSheet->getPageSetup()->setHorizontalCentered(true);
                             }
                             if ($xmlSheet->printOptions['verticalCentered']) {
                                 $docSheet->getPageSetup()->setVerticalCentered(true);

 /**
  * Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column
  * to indicate offsets from a base cell
  * section 3.3.4
  *
  * @param string $subData
  * @param string $baseCell Base cell
  * @return string Cell range address
  */
 private function _readBIFF8CellRangeAddressB($subData, $baseCell = 'A1')
 {
     list($baseCol, $baseRow) = Cell::coordinateFromString($baseCell);
     $baseCol = Cell::columnIndexFromString($baseCol) - 1;
     // TODO: if cell range is just a single cell, should this funciton
     // not just return e.g. 'A1' and not 'A1:A1' ?
     // offset: 0; size: 2; first row
     $frIndex = $this->_GetInt2d($subData, 0);
     // adjust below
     // offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767)
     $lrIndex = $this->_GetInt2d($subData, 2);
     // adjust below
     // offset: 4; size: 2; first column with relative/absolute flags
     // bit: 7-0; mask 0x00FF; column index
     $fcIndex = 0xff & $this->_GetInt2d($subData, 4);
     // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
     if (!(0x4000 & $this->_GetInt2d($subData, 4))) {
         // absolute column index
         $fc = Cell::stringFromColumnIndex($fcIndex);
         $fc = '$' . $fc;
     } else {
         // column offset
         $fcIndex = $fcIndex <= 127 ? $fcIndex : $fcIndex - 256;
         $fc = Cell::stringFromColumnIndex($baseCol + $fcIndex);
     }
     // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
     if (!(0x8000 & $this->_GetInt2d($subData, 4))) {
         // absolute row index
         $fr = $frIndex + 1;
         $fr = '$' . $fr;
     } else {
         // row offset
         $frIndex = $frIndex <= 32767 ? $frIndex : $frIndex - 65536;
         $fr = $baseRow + $frIndex;
     }
     // offset: 6; size: 2; last column with relative/absolute flags
     // bit: 7-0; mask 0x00FF; column index
     $lcIndex = 0xff & $this->_GetInt2d($subData, 6);
     $lcIndex = $lcIndex <= 127 ? $lcIndex : $lcIndex - 256;
     $lc = Cell::stringFromColumnIndex($baseCol + $lcIndex);
     // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
     if (!(0x4000 & $this->_GetInt2d($subData, 6))) {
         // absolute column index
         $lc = Cell::stringFromColumnIndex($lcIndex);
         $lc = '$' . $lc;
     } else {
         // column offset
         $lcIndex = $lcIndex <= 127 ? $lcIndex : $lcIndex - 256;
         $lc = Cell::stringFromColumnIndex($baseCol + $lcIndex);
     }
     // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
     if (!(0x8000 & $this->_GetInt2d($subData, 6))) {
         // absolute row index
         $lr = $lrIndex + 1;
         $lr = '$' . $lr;
     } else {
         // row offset
         $lrIndex = $lrIndex <= 32767 ? $lrIndex : $lrIndex - 65536;
         $lr = $baseRow + $lrIndex;
     }
     return "{$fc}{$fr}:{$lc}{$lr}";
 }

 /**
  *	Loads PHPExcel from file into PHPExcel instance
  *
  *	@access	public
  *	@param 	string 		$pFilename
  *	@param	PHPExcel	$objPHPExcel
  *	@return 	PHPExcel
  *	@throws 	Exception
  */
 public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
 {
     // Check if file exists
     if (!file_exists($pFilename)) {
         throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
     }
     // Create new PHPExcel
     while ($objPHPExcel->getSheetCount() <= $this->_sheetIndex) {
         $objPHPExcel->createSheet();
     }
     $objPHPExcel->setActiveSheetIndex($this->_sheetIndex);
     // Open file
     $fileHandle = fopen($pFilename, 'r');
     if ($fileHandle === false) {
         throw new Exception("Could not open file {$pFilename} for reading.");
     }
     // Skip BOM, if any
     switch ($this->_inputEncoding) {
         case 'UTF-8':
             fgets($fileHandle, 4) == "" ? fseek($fileHandle, 3) : fseek($fileHandle, 0);
             break;
         default:
             break;
     }
     // Loop through file
     $currentRow = 0;
     $rowData = array();
     while (($rowData = fgetcsv($fileHandle, 0, $this->_delimiter, $this->_enclosure)) !== FALSE) {
         ++$currentRow;
         $rowDataCount = count($rowData);
         for ($i = 0; $i < $rowDataCount; ++$i) {
             $columnLetter = Cell::stringFromColumnIndex($i);
             if ($rowData[$i] != '' && $this->_readFilter->readCell($columnLetter, $currentRow)) {
                 // Unescape enclosures
                 $rowData[$i] = str_replace("\\" . $this->_enclosure, $this->_enclosure, $rowData[$i]);
                 $rowData[$i] = str_replace($this->_enclosure . $this->_enclosure, $this->_enclosure, $rowData[$i]);
                 // Convert encoding if necessary
                 if ($this->_inputEncoding !== 'UTF-8') {
                     $rowData[$i] = Shared_String::ConvertEncoding($rowData[$i], 'UTF-8', $this->_inputEncoding);
                 }
                 // Set cell value
                 $objPHPExcel->getActiveSheet()->getCell($columnLetter . $currentRow)->setValue($rowData[$i]);
             }
         }
     }
     // Close file
     fclose($fileHandle);
     // Return
     return $objPHPExcel;
 }

//.........这里部分代码省略.........
                         }
                     }
                     unset($pStyles['borders']['allborders']);
                     // not needed any more
                 }
                 // 'outline' is a shorthand property for 'top', 'right', 'bottom', 'left'
                 //        it applies to components that have not been set explicitly
                 if (isset($pStyles['borders']['outline'])) {
                     foreach (array('top', 'right', 'bottom', 'left') as $component) {
                         if (!isset($pStyles['borders'][$component])) {
                             $pStyles['borders'][$component] = $pStyles['borders']['outline'];
                         }
                     }
                     unset($pStyles['borders']['outline']);
                     // not needed any more
                 }
                 // 'inside' is a shorthand property for 'vertical' and 'horizontal'
                 //        it applies to components that have not been set explicitly
                 if (isset($pStyles['borders']['inside'])) {
                     foreach (array('vertical', 'horizontal') as $component) {
                         if (!isset($pStyles['borders'][$component])) {
                             $pStyles['borders'][$component] = $pStyles['borders']['inside'];
                         }
                     }
                     unset($pStyles['borders']['inside']);
                     // not needed any more
                 }
                 // width and height characteristics of selection, 1, 2, or 3 (for 3 or more)
                 $xMax = min($rangeEnd[0] - $rangeStart[0] + 1, 3);
                 $yMax = min($rangeEnd[1] - $rangeStart[1] + 1, 3);
                 // loop through up to 3 x 3 = 9 regions
                 for ($x = 1; $x <= $xMax; ++$x) {
                     // start column index for region
                     $colStart = $x == 3 ? Cell::stringFromColumnIndex($rangeEnd[0]) : Cell::stringFromColumnIndex($rangeStart[0] + $x - 1);
                     // end column index for region
                     $colEnd = $x == 1 ? Cell::stringFromColumnIndex($rangeStart[0]) : Cell::stringFromColumnIndex($rangeEnd[0] - $xMax + $x);
                     for ($y = 1; $y <= $yMax; ++$y) {
                         // which edges are touching the region
                         $edges = array();
                         if ($x == 1) {
                             // are we at left edge
                             $edges[] = 'left';
                         }
                         if ($x == $xMax) {
                             // are we at right edge
                             $edges[] = 'right';
                         }
                         if ($y == 1) {
                             // are we at top edge?
                             $edges[] = 'top';
                         }
                         if ($y == $yMax) {
                             // are we at bottom edge?
                             $edges[] = 'bottom';
                         }
                         // start row index for region
                         $rowStart = $y == 3 ? $rangeEnd[1] : $rangeStart[1] + $y - 1;
                         // end row index for region
                         $rowEnd = $y == 1 ? $rangeStart[1] : $rangeEnd[1] - $yMax + $y;
                         // build range for region
                         $range = $colStart . $rowStart . ':' . $colEnd . $rowEnd;
                         // retrieve relevant style array for region
                         $regionStyles = $pStyles;
                         unset($regionStyles['borders']['inside']);
                         // what are the inner edges of the region when looking at the selection
                         $innerEdges = array_diff(array('top', 'right', 'bottom', 'left'), $edges);

 /**
  * Update single cell reference
  *
  * @param    string    $pCellReference        Single cell reference
  * @param    int        $pBefore            Insert before this one
  * @param    int        $pNumCols            Number of columns to increment
  * @param    int        $pNumRows            Number of rows to increment
  * @return    string    Updated cell reference
  * @throws    Exception
  */
 private function updateSingleCellReference($pCellReference = 'A1', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0)
 {
     if (strpos($pCellReference, ':') === false && strpos($pCellReference, ',') === false) {
         // Get coordinates of $pBefore
         list($beforeColumn, $beforeRow) = Cell::coordinateFromString($pBefore);
         // Get coordinates of $pCellReference
         list($newColumn, $newRow) = Cell::coordinateFromString($pCellReference);
         // Verify which parts should be updated
         $updateColumn = $newColumn[0] != '$' && $beforeColumn[0] != '$' && Cell::columnIndexFromString($newColumn) >= Cell::columnIndexFromString($beforeColumn);
         $updateRow = $newRow[0] != '$' && $beforeRow[0] != '$' && $newRow >= $beforeRow;
         // Create new column reference
         if ($updateColumn) {
             $newColumn = Cell::stringFromColumnIndex(Cell::columnIndexFromString($newColumn) - 1 + $pNumCols);
         }
         // Create new row reference
         if ($updateRow) {
             $newRow = $newRow + $pNumRows;
         }
         // Return new reference
         return $newColumn . $newRow;
     } else {
         throw new Exception("Only single cell references may be passed to this method.");
     }
 }

 /**
  * Accepts a range, returning it as a range that falls within the current highest row and column of the worksheet
  *
  * @param 	string 	$range
  * @return 	string	Adjusted range value
  */
 public function shrinkRangeToFit($range)
 {
     $maxCol = $this->getHighestColumn();
     $maxRow = $this->getHighestRow();
     $maxCol = Cell::columnIndexFromString($maxCol);
     $rangeBlocks = explode(' ', $range);
     foreach ($rangeBlocks as &$rangeSet) {
         $rangeBoundaries = Cell::getRangeBoundaries($rangeSet);
         if (Cell::columnIndexFromString($rangeBoundaries[0][0]) > $maxCol) {
             $rangeBoundaries[0][0] = Cell::stringFromColumnIndex($maxCol);
         }
         if ($rangeBoundaries[0][1] > $maxRow) {
             $rangeBoundaries[0][1] = $maxRow;
         }
         if (Cell::columnIndexFromString($rangeBoundaries[1][0]) > $maxCol) {
             $rangeBoundaries[1][0] = Cell::stringFromColumnIndex($maxCol);
         }
         if ($rangeBoundaries[1][1] > $maxRow) {
             $rangeBoundaries[1][1] = $maxRow;
         }
         $rangeSet = $rangeBoundaries[0][0] . $rangeBoundaries[0][1] . ':' . $rangeBoundaries[1][0] . $rangeBoundaries[1][1];
     }
     unset($rangeSet);
     $stRange = implode(' ', $rangeBlocks);
     return $stRange;
 }

//.........这里部分代码省略.........
                         if ($styleAttributeValue > '') {
                             $this->_styles[$styleID]['numberformat']['code'] = $styleAttributeValue;
                         }
                     }
                     break;
                 case 'Protection':
                     foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
                         //								echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />';
                     }
                     break;
             }
         }
         //			print_r($this->_styles[$styleID]);
         //			echo '<hr />';
     }
     //		echo '<hr />';
     $worksheetID = 0;
     foreach ($xml->Worksheet as $worksheet) {
         $worksheet_ss = $worksheet->attributes($namespaces['ss']);
         if (isset($this->_loadSheetsOnly) && isset($worksheet_ss['Name']) && !in_array($worksheet_ss['Name'], $this->_loadSheetsOnly)) {
             continue;
         }
         // Create new Worksheet
         $objPHPExcel->createSheet();
         $objPHPExcel->setActiveSheetIndex($worksheetID);
         if (isset($worksheet_ss['Name'])) {
             $worksheetName = (string) $worksheet_ss['Name'];
             $objPHPExcel->getActiveSheet()->setTitle($worksheetName);
         }
         $columnID = 'A';
         foreach ($worksheet->Table->Column as $columnData) {
             $columnData_ss = $columnData->attributes($namespaces['ss']);
             if (isset($columnData_ss['Index'])) {
                 $columnID = Cell::stringFromColumnIndex($columnData_ss['Index'] - 1);
             }
             if (isset($columnData_ss['Width'])) {
                 $columnWidth = $columnData_ss['Width'];
                 //					echo '<b>Setting column width for '.$columnID.' to '.$columnWidth.'</b><br />';
                 $objPHPExcel->getActiveSheet()->getColumnDimension($columnID)->setWidth($columnWidth / 5.4);
             }
             ++$columnID;
         }
         $rowID = 1;
         foreach ($worksheet->Table->Row as $rowData) {
             $row_ss = $rowData->attributes($namespaces['ss']);
             if (isset($row_ss['Index'])) {
                 $rowID = (int) $row_ss['Index'];
             }
             //				echo '<b>Row '.$rowID.'</b><br />';
             if (isset($row_ss['StyleID'])) {
                 $rowStyle = $row_ss['StyleID'];
             }
             if (isset($row_ss['Height'])) {
                 $rowHeight = $row_ss['Height'];
                 //					echo '<b>Setting row height to '.$rowHeight.'</b><br />';
                 $objPHPExcel->getActiveSheet()->getRowDimension($rowID)->setRowHeight($rowHeight);
             }
             $columnID = 'A';
             foreach ($rowData->Cell as $cell) {
                 $cell_ss = $cell->attributes($namespaces['ss']);
                 if (isset($cell_ss['Index'])) {
                     $columnID = Cell::stringFromColumnIndex($cell_ss['Index'] - 1);
                 }
                 $cellRange = $columnID . $rowID;
                 if (isset($cell_ss['MergeAcross']) || isset($cell_ss['MergeDown'])) {
                     $columnTo = $columnID;

 /**
  * Convert 1-cell anchor coordinates to 2-cell anchor coordinates
  * This function is ported from PEAR Spreadsheet_Writer_Excel with small modifications
  *
  * Calculate the vertices that define the position of the image as required by
  * the OBJ record.
  *
  *		 +------------+------------+
  *		 |	 A	  |	  B	 |
  *   +-----+------------+------------+
  *   |	 |(x1,y1)	 |			|
  *   |  1  |(A1)._______|______	  |
  *   |	 |	|			  |	 |
  *   |	 |	|			  |	 |
  *   +-----+----|	BITMAP	|-----+
  *   |	 |	|			  |	 |
  *   |  2  |	|______________.	 |
  *   |	 |			|		(B2)|
  *   |	 |			|	 (x2,y2)|
  *   +---- +------------+------------+
  *
  * Example of a bitmap that covers some of the area from cell A1 to cell B2.
  *
  * Based on the width and height of the bitmap we need to calculate 8 vars:
  *	 $col_start, $row_start, $col_end, $row_end, $x1, $y1, $x2, $y2.
  * The width and height of the cells are also variable and have to be taken into
  * account.
  * The values of $col_start and $row_start are passed in from the calling
  * function. The values of $col_end and $row_end are calculated by subtracting
  * the width and height of the bitmap from the width and height of the
  * underlying cells.
  * The vertices are expressed as a percentage of the underlying cell width as
  * follows (rhs values are in pixels):
  *
  *	   x1 = X / W *1024
  *	   y1 = Y / H *256
  *	   x2 = (X-1) / W *1024
  *	   y2 = (Y-1) / H *256
  *
  *	   Where:  X is distance from the left side of the underlying cell
  *			   Y is distance from the top of the underlying cell
  *			   W is the width of the cell
  *			   H is the height of the cell
  *
  * @param Worksheet $sheet
  * @param string $coordinates E.g. 'A1'
  * @param integer $offsetX Horizontal offset in pixels
  * @param integer $offsetY Vertical offset in pixels
  * @param integer $width Width in pixels
  * @param integer $height Height in pixels
  * @return array
  */
 public static function oneAnchor2twoAnchor($sheet, $coordinates, $offsetX, $offsetY, $width, $height)
 {
     list($column, $row) = Cell::coordinateFromString($coordinates);
     $col_start = Cell::columnIndexFromString($column) - 1;
     $row_start = $row - 1;
     $x1 = $offsetX;
     $y1 = $offsetY;
     // 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 >= self::sizeCol($sheet, Cell::stringFromColumnIndex($col_start))) {
         $x1 = 0;
     }
     if ($y1 >= self::sizeRow($sheet, $row_start + 1)) {
         $y1 = 0;
     }
     $width = $width + $x1 - 1;
     $height = $height + $y1 - 1;
     // Subtract the underlying cell widths to find the end cell of the image
     while ($width >= self::sizeCol($sheet, Cell::stringFromColumnIndex($col_end))) {
         $width -= self::sizeCol($sheet, Cell::stringFromColumnIndex($col_end));
         ++$col_end;
     }
     // Subtract the underlying cell heights to find the end cell of the image
     while ($height >= self::sizeRow($sheet, $row_end + 1)) {
         $height -= self::sizeRow($sheet, $row_end + 1);
         ++$row_end;
     }
     // Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
     // with zero height or width.
     if (self::sizeCol($sheet, Cell::stringFromColumnIndex($col_start)) == 0) {
         return;
     }
     if (self::sizeCol($sheet, Cell::stringFromColumnIndex($col_end)) == 0) {
         return;
     }
     if (self::sizeRow($sheet, $row_start + 1) == 0) {
         return;
     }
     if (self::sizeRow($sheet, $row_end + 1) == 0) {
         return;
     }
     // Convert the pixel values to the percentage value expected by Excel
     $x1 = $x1 / self::sizeCol($sheet, Cell::stringFromColumnIndex($col_start)) * 1024;
     $y1 = $y1 / self::sizeRow($sheet, $row_start + 1) * 256;
//.........这里部分代码省略.........

 /**
  * Extract all cell references in range
  *
  * @param 	string 	$pRange		Range (e.g. A1 or A1:A10 or A1:A10 A100:A1000)
  * @return 	array	Array containing single cell references
  */
 public static function extractAllCellReferencesInRange($pRange = 'A1')
 {
     // Returnvalue
     $returnValue = array();
     // Explode spaces
     $aExplodeSpaces = explode(' ', str_replace('$', '', strtoupper($pRange)));
     foreach ($aExplodeSpaces as $explodedSpaces) {
         // Single cell?
         if (strpos($explodedSpaces, ':') === false && strpos($explodedSpaces, ',') === false) {
             $col = 'A';
             $row = 1;
             list($col, $row) = Cell::coordinateFromString($explodedSpaces);
             if (strlen($col) <= 2) {
                 $returnValue[] = $explodedSpaces;
             }
             continue;
         }
         // Range...
         $range = Cell::splitRange($explodedSpaces);
         for ($i = 0; $i < count($range); ++$i) {
             // Single cell?
             if (count($range[$i]) == 1) {
                 $col = 'A';
                 $row = 1;
                 list($col, $row) = Cell::coordinateFromString($range[$i]);
                 if (strlen($col) <= 2) {
                     $returnValue[] = $explodedSpaces;
                 }
             }
             // Range...
             $rangeStart = $rangeEnd = '';
             $startingCol = $startingRow = $endingCol = $endingRow = 0;
             list($rangeStart, $rangeEnd) = $range[$i];
             list($startingCol, $startingRow) = Cell::coordinateFromString($rangeStart);
             list($endingCol, $endingRow) = Cell::coordinateFromString($rangeEnd);
             // Conversions...
             $startingCol = Cell::columnIndexFromString($startingCol);
             $endingCol = Cell::columnIndexFromString($endingCol);
             // Current data
             $currentCol = --$startingCol;
             $currentRow = $startingRow;
             // Loop cells
             while ($currentCol < $endingCol) {
                 $loopColumn = Cell::stringFromColumnIndex($currentCol);
                 while ($currentRow <= $endingRow) {
                     $returnValue[] = $loopColumn . $currentRow;
                     ++$currentRow;
                 }
                 ++$currentCol;
                 $currentRow = $startingRow;
             }
         }
     }
     // Return value
     return $returnValue;
 }

 /**
  * Set print area
  *
  * @param int $column1		Column 1
  * @param int $row1			Row 1
  * @param int $column2		Column 2
  * @param int $row2			Row 2
  * @return Worksheet_PageSetup
  */
 public function setPrintAreaByColumnAndRow($column1, $row1, $column2, $row2)
 {
     return $this->setPrintArea(Cell::stringFromColumnIndex($column1) . $row1 . ':' . Cell::stringFromColumnIndex($column2) . $row2);
 }

 /**
  * Generate row
  *
  * @param	Worksheet 	$pSheet			Worksheet
  * @param	array				$pValues		Array containing cells in a row
  * @param	int					$pRow			Row number (0-based)
  * @return	string
  * @throws	Exception
  */
 private function _generateRow(Worksheet $pSheet, $pValues = null, $pRow = 0)
 {
     if (is_array($pValues)) {
         // Construct HTML
         $html = '';
         // Sheet index
         $sheetIndex = $pSheet->getParent()->getIndex($pSheet);
         // TCPDF and breaks
         if ($this->_isPdf && count($pSheet->getBreaks()) > 0) {
             $breaks = $pSheet->getBreaks();
             // check if a break is needed before this row
             if (isset($breaks['A' . $pRow])) {
                 // close table: </table>
                 $html .= $this->_generateTableFooter();
                 // insert page break
                 $html .= '<tcpdf method="AddPage" />';
                 // open table again: <table> + <col> etc.
                 $html .= $this->_generateTableHeader($pSheet);
             }
         }
         // Write row start
         if (!$this->_useInlineCss) {
             $html .= '          <tr class="row' . $pRow . '">' . "\r\n";
         } else {
             $style = isset($this->_cssStyles['table.sheet' . $sheetIndex . ' tr.row' . $pRow]) ? $this->_assembleCSS($this->_cssStyles['table.sheet' . $sheetIndex . ' tr.row' . $pRow]) : '';
             $html .= '          <tr style="' . $style . '">' . "\r\n";
         }
         // Write cells
         $colNum = 0;
         foreach ($pValues as $cell) {
             $coordinate = Cell::stringFromColumnIndex($colNum) . ($pRow + 1);
             if (!$this->_useInlineCss) {
                 $cssClass = '';
                 $cssClass = 'column' . $colNum;
             } else {
                 $cssClass = array();
                 if (isset($this->_cssStyles['table.sheet' . $sheetIndex . ' td.column' . $colNum])) {
                     $this->_cssStyles['table.sheet' . $sheetIndex . ' td.column' . $colNum];
                 }
             }
             $colSpan = 1;
             $rowSpan = 1;
             $writeCell = true;
             // Write cell
             // initialize
             $cellData = '';
             // Cell
             if ($cell instanceof Cell) {
                 if (is_null($cell->getParent())) {
                     $cell->attach($pSheet);
                 }
                 // Value
                 if ($cell->getValue() instanceof RichText) {
                     // Loop through rich text elements
                     $elements = $cell->getValue()->getRichTextElements();
                     foreach ($elements as $element) {
                         // Rich text start?
                         if ($element instanceof RichText_Run) {
                             $cellData .= '<span style="' . $this->_assembleCSS($this->_createCSSStyleFont($element->getFont())) . '">';
                             if ($element->getFont()->getSuperScript()) {
                                 $cellData .= '<sup>';
                             } else {
                                 if ($element->getFont()->getSubScript()) {
                                     $cellData .= '<sub>';
                                 }
                             }
                         }
                         // Convert UTF8 data to PCDATA
                         $cellText = $element->getText();
                         $cellData .= htmlspecialchars($cellText);
                         if ($element instanceof RichText_Run) {
                             if ($element->getFont()->getSuperScript()) {
                                 $cellData .= '</sup>';
                             } else {
                                 if ($element->getFont()->getSubScript()) {
                                     $cellData .= '</sub>';
                                 }
                             }
                             $cellData .= '</span>';
                         }
                     }
                 } else {
                     if ($this->_preCalculateFormulas) {
                         $cellData = Style_NumberFormat::toFormattedString($cell->getCalculatedValue(), $pSheet->getParent()->getCellXfByIndex($cell->getXfIndex())->getNumberFormat()->getFormatCode(), array($this, 'formatColor'));
                     } else {
                         $cellData = Style_NumberFormat::ToFormattedString($cell->getValue(), $pSheet->getParent()->getCellXfByIndex($cell->getXfIndex())->getNumberFormat()->getFormatCode(), array($this, 'formatColor'));
                     }
                 }
                 // replace leading spaces on each line with &nbsp;
                 $cellData = $this->_convertNbsp($cellData);
                 // convert newline "\n" to '<br>'
//.........这里部分代码省略.........

 /**
  *	OFFSET
  *
  *	Returns a reference to a range that is a specified number of rows and columns from a cell or range of cells.
  *	The reference that is returned can be a single cell or a range of cells. You can specify the number of rows and
  *	the number of columns to be returned.
  *
  *	@param	cellAddress		The reference from which you want to base the offset. Reference must refer to a cell or
  *								range of adjacent cells; otherwise, OFFSET returns the #VALUE! error value.
  *	@param	rows			The number of rows, up or down, that you want the upper-left cell to refer to.
  *								Using 5 as the rows argument specifies that the upper-left cell in the reference is
  *								five rows below reference. Rows can be positive (which means below the starting reference)
  *								or negative (which means above the starting reference).
  *	@param	cols			The number of columns, to the left or right, that you want the upper-left cell of the result
  *								to refer to. Using 5 as the cols argument specifies that the upper-left cell in the
  *								reference is five columns to the right of reference. Cols can be positive (which means
  *								to the right of the starting reference) or negative (which means to the left of the
  *								starting reference).
  *	@param	height			The height, in number of rows, that you want the returned reference to be. Height must be a positive number.
  *	@param	width			The width, in number of columns, that you want the returned reference to be. Width must be a positive number.
  *	@return	string			A reference to a cell or range of cells
  */
 public static function OFFSET($cellAddress = Null, $rows = 0, $columns = 0, $height = null, $width = null)
 {
     $rows = self::flattenSingleValue($rows);
     $columns = self::flattenSingleValue($columns);
     $height = self::flattenSingleValue($height);
     $width = self::flattenSingleValue($width);
     if ($cellAddress == Null) {
         return 0;
     }
     $args = func_get_args();
     $pCell = array_pop($args);
     if (!is_object($pCell)) {
         return self::$_errorCodes['reference'];
     }
     $sheetName = null;
     if (strpos($cellAddress, "!")) {
         list($sheetName, $cellAddress) = explode("!", $cellAddress);
     }
     if (strpos($cellAddress, ":")) {
         list($startCell, $endCell) = explode(":", $cellAddress);
     } else {
         $startCell = $endCell = $cellAddress;
     }
     list($startCellColumn, $startCellRow) = Cell::coordinateFromString($startCell);
     list($endCellColumn, $endCellRow) = Cell::coordinateFromString($endCell);
     $startCellRow += $rows;
     $startCellColumn = Cell::columnIndexFromString($startCellColumn) - 1;
     $startCellColumn += $columns;
     if ($startCellRow <= 0 || $startCellColumn < 0) {
         return self::$_errorCodes['reference'];
     }
     $endCellColumn = Cell::columnIndexFromString($endCellColumn) - 1;
     if ($width != null && !is_object($width)) {
         $endCellColumn = $startCellColumn + $width - 1;
     } else {
         $endCellColumn += $columns;
     }
     $startCellColumn = Cell::stringFromColumnIndex($startCellColumn);
     if ($height != null && !is_object($height)) {
         $endCellRow = $startCellRow + $height - 1;
     } else {
         $endCellRow += $rows;
     }
     if ($endCellRow <= 0 || $endCellColumn < 0) {
         return self::$_errorCodes['reference'];
     }
     $endCellColumn = Cell::stringFromColumnIndex($endCellColumn);
     $cellAddress = $startCellColumn . $startCellRow;
     if ($startCellColumn != $endCellColumn || $startCellRow != $endCellRow) {
         $cellAddress .= ':' . $endCellColumn . $endCellRow;
     }
     if ($sheetName !== null) {
         $pSheet = $pCell->getParent()->getParent()->getSheetByName($sheetName);
     } else {
         $pSheet = $pCell->getParent();
     }
     return Calculation::getInstance()->extractCellRange($cellAddress, $pSheet, False);
 }

 private function processTokenStack($tokens, $cellID = null, Cell $pCell = null)
 {
     if ($tokens == false) {
         return false;
     }
     //    If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent cell collection),
     //        so we store the parent cell collection so that we can re-attach it when necessary
     $pCellWorksheet = $pCell !== null ? $pCell->getWorksheet() : null;
     $pCellParent = $pCell !== null ? $pCell->getParent() : null;
     $stack = new Calculation\Token\Stack();
     //    Loop through each token in turn
     foreach ($tokens as $tokenData) {
         //            print_r($tokenData);
         //            echo '<br />';
         $token = $tokenData['value'];
         //            echo '<b>Token is '.$token.'</b><br />';
         // if the token is a binary operator, pop the top two values off the stack, do the operation, and push the result back on the stack
         if (isset(self::$binaryOperators[$token])) {
             //                echo 'Token is a binary operator<br />';
             //    We must have two operands, error if we don't
             if (($operand2Data = $stack->pop()) === null) {
                 return $this->raiseFormulaError('Internal error - Operand value missing from stack');
             }
             if (($operand1Data = $stack->pop()) === null) {
                 return $this->raiseFormulaError('Internal error - Operand value missing from stack');
             }
             $operand1 = self::dataTestReference($operand1Data);
             $operand2 = self::dataTestReference($operand2Data);
             //    Log what we're doing
             if ($token == ':') {
                 $this->_debugLog->writeDebugLog('Evaluating Range ', $this->showValue($operand1Data['reference']), ' ', $token, ' ', $this->showValue($operand2Data['reference']));
             } else {
                 $this->_debugLog->writeDebugLog('Evaluating ', $this->showValue($operand1), ' ', $token, ' ', $this->showValue($operand2));
             }
             //    Process the operation in the appropriate manner
             switch ($token) {
                 //    Comparison (Boolean) Operators
                 case '>':
                     //    Greater than
                 //    Greater than
                 case '<':
                     //    Less than
                 //    Less than
                 case '>=':
                     //    Greater than or Equal to
                 //    Greater than or Equal to
                 case '<=':
                     //    Less than or Equal to
                 //    Less than or Equal to
                 case '=':
                     //    Equality
                 //    Equality
                 case '<>':
                     //    Inequality
                     $this->executeBinaryComparisonOperation($cellID, $operand1, $operand2, $token, $stack);
                     break;
                     //    Binary Operators
                 //    Binary Operators
                 case ':':
                     //    Range
                     $sheet1 = $sheet2 = '';
                     if (strpos($operand1Data['reference'], '!') !== false) {
                         list($sheet1, $operand1Data['reference']) = explode('!', $operand1Data['reference']);
                     } else {
                         $sheet1 = $pCellParent !== null ? $pCellWorksheet->getTitle() : '';
                     }
                     if (strpos($operand2Data['reference'], '!') !== false) {
                         list($sheet2, $operand2Data['reference']) = explode('!', $operand2Data['reference']);
                     } else {
                         $sheet2 = $sheet1;
                     }
                     if ($sheet1 == $sheet2) {
                         if ($operand1Data['reference'] === null) {
                             if (trim($operand1Data['value']) != '' && is_numeric($operand1Data['value'])) {
                                 $operand1Data['reference'] = $pCell->getColumn() . $operand1Data['value'];
                             } elseif (trim($operand1Data['reference']) == '') {
                                 $operand1Data['reference'] = $pCell->getCoordinate();
                             } else {
                                 $operand1Data['reference'] = $operand1Data['value'] . $pCell->getRow();
                             }
                         }
                         if ($operand2Data['reference'] === null) {
                             if (trim($operand2Data['value']) != '' && is_numeric($operand2Data['value'])) {
                                 $operand2Data['reference'] = $pCell->getColumn() . $operand2Data['value'];
                             } elseif (trim($operand2Data['reference']) == '') {
                                 $operand2Data['reference'] = $pCell->getCoordinate();
                             } else {
                                 $operand2Data['reference'] = $operand2Data['value'] . $pCell->getRow();
                             }
                         }
                         $oData = array_merge(explode(':', $operand1Data['reference']), explode(':', $operand2Data['reference']));
                         $oCol = $oRow = array();
                         foreach ($oData as $oDatum) {
                             $oCR = Cell::coordinateFromString($oDatum);
                             $oCol[] = Cell::columnIndexFromString($oCR[0]) - 1;
                             $oRow[] = $oCR[1];
                         }
                         $cellRef = Cell::stringFromColumnIndex(min($oCol)) . min($oRow) . ':' . Cell::stringFromColumnIndex(max($oCol)) . max($oRow);
                         if ($pCellParent !== null) {
                             $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($sheet1), false);
//.........这里部分代码省略.........

 /**
  * Calculate the vertices that define the position of the image as required by
  * the OBJ record.
  *
  *		 +------------+------------+
  *		 |	 A	  |	  B	 |
  *   +-----+------------+------------+
  *   |	 |(x1,y1)	 |			|
  *   |  1  |(A1)._______|______	  |
  *   |	 |	|			  |	 |
  *   |	 |	|			  |	 |
  *   +-----+----|	BITMAP	|-----+
  *   |	 |	|			  |	 |
  *   |  2  |	|______________.	 |
  *   |	 |			|		(B2)|
  *   |	 |			|	 (x2,y2)|
  *   +---- +------------+------------+
  *
  * Example of a bitmap that covers some of the area from cell A1 to cell B2.
  *
  * Based on the width and height of the bitmap we need to calculate 8 vars:
  *	 $col_start, $row_start, $col_end, $row_end, $x1, $y1, $x2, $y2.
  * The width and height of the cells are also variable and have to be taken into
  * account.
  * The values of $col_start and $row_start are passed in from the calling
  * function. The values of $col_end and $row_end are calculated by subtracting
  * the width and height of the bitmap from the width and height of the
  * underlying cells.
  * The vertices are expressed as a percentage of the underlying cell width as
  * follows (rhs values are in pixels):
  *
  *	   x1 = X / W *1024
  *	   y1 = Y / H *256
  *	   x2 = (X-1) / W *1024
  *	   y2 = (Y-1) / H *256
  *
  *	   Where:  X is distance from the left side of the underlying cell
  *			   Y is distance from the top of the underlying cell
  *			   W is the width of the cell
  *			   H is the height of the cell
  * The SDK incorrectly states that the height should be expressed as a
  *		percentage of 1024.
  *
  * @access private
  * @param integer $col_start Col containing upper left corner of object
  * @param integer $row_start Row containing top left corner of object
  * @param integer $x1		Distance to left side of object
  * @param integer $y1		Distance to top of object
  * @param integer $width	 Width of image frame
  * @param integer $height	Height of image frame
  */
 function _positionImage($col_start, $row_start, $x1, $y1, $width, $height)
 {
     // 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 >= Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_start))) {
         $x1 = 0;
     }
     if ($y1 >= Shared_Excel5::sizeRow($this->_phpSheet, $row_start + 1)) {
         $y1 = 0;
     }
     $width = $width + $x1 - 1;
     $height = $height + $y1 - 1;
     // Subtract the underlying cell widths to find the end cell of the image
     while ($width >= Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_end))) {
         $width -= Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_end));
         ++$col_end;
     }
     // Subtract the underlying cell heights to find the end cell of the image
     while ($height >= Shared_Excel5::sizeRow($this->_phpSheet, $row_end + 1)) {
         $height -= Shared_Excel5::sizeRow($this->_phpSheet, $row_end + 1);
         ++$row_end;
     }
     // Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
     // with zero eight or width.
     //
     if (Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_start)) == 0) {
         return;
     }
     if (Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_end)) == 0) {
         return;
     }
     if (Shared_Excel5::sizeRow($this->_phpSheet, $row_start + 1) == 0) {
         return;
     }
     if (Shared_Excel5::sizeRow($this->_phpSheet, $row_end + 1) == 0) {
         return;
     }
     // Convert the pixel values to the percentage value expected by Excel
     $x1 = $x1 / Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_start)) * 1024;
     $y1 = $y1 / Shared_Excel5::sizeRow($this->_phpSheet, $row_start + 1) * 256;
     $x2 = $width / Shared_Excel5::sizeCol($this->_phpSheet, Cell::stringFromColumnIndex($col_end)) * 1024;
     // Distance to right side of object
     $y2 = $height / Shared_Excel5::sizeRow($this->_phpSheet, $row_end + 1) * 256;
     // Distance to bottom of object
     $this->_writeObjPicture($col_start, $x1, $row_start, $y1, $col_end, $x2, $row_end, $y2);
//.........这里部分代码省略.........