PHP PHPExcel_Cell::getWorksheet方法代码示例

 public static function write(PHPExcel_Shared_XMLWriter $objWriter, PHPExcel_Cell $cell)
 {
     $comments = $cell->getWorksheet()->getComments();
     if (! isset($comments[$cell->getCoordinate()])) {
         return;
     }
     $comment = $comments[$cell->getCoordinate()];
     
     $objWriter->startElement('office:annotation');
     // $objWriter->writeAttribute('draw:style-name', 'gr1');
     // $objWriter->writeAttribute('draw:text-style-name', 'P1');
     $objWriter->writeAttribute('svg:width', $comment->getWidth());
     $objWriter->writeAttribute('svg:height', $comment->getHeight());
     $objWriter->writeAttribute('svg:x', $comment->getMarginLeft());
     $objWriter->writeAttribute('svg:y', $comment->getMarginTop());
     // $objWriter->writeAttribute('draw:caption-point-x', $comment->getMarginLeft());
     // $objWriter->writeAttribute('draw:caption-point-y', $comment->getMarginTop());
     $objWriter->writeElement('dc:creator', $comment->getAuthor());
     // TODO: Not realized in PHPExcel_Comment yet.
     // $objWriter->writeElement('dc:date', $comment->getDate());
     $objWriter->writeElement('text:p', $comment->getText()
         ->getPlainText());
     // $objWriter->writeAttribute('draw:text-style-name', 'P1');
     $objWriter->endElement();
 }

 private function _processTokenStack($tokens, $cellID = NULL, PHPExcel_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 PHPExcel_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 = PHPExcel_Cell::coordinateFromString($oDatum);
                             $oCol[] = PHPExcel_Cell::columnIndexFromString($oCR[0]) - 1;
                             $oRow[] = $oCR[1];
                         }
                         $cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)) . min($oRow) . ':' . PHPExcel_Cell::stringFromColumnIndex(max($oCol)) . max($oRow);
                         if ($pCellParent !== NULL) {
                             $cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($sheet1), FALSE);
//.........这里部分代码省略.........

 /**
  * INDIRECT
  *
  * Returns the reference specified by a text string.
  * References are immediately evaluated to display their contents.
  *
  * Excel Function:
  *		=INDIRECT(cellAddress)
  *
  * NOTE - INDIRECT() does not yet support the optional a1 parameter introduced in Excel 2010
  *
  * @param	cellAddress		$cellAddress	The cell address of the current cell (containing this formula)
  * @param	PHPExcel_Cell	$pCell			The current cell (containing this formula)
  * @return	mixed			The cells referenced by cellAddress
  *
  * @todo	Support for the optional a1 parameter introduced in Excel 2010
  *
  */
 public static function INDIRECT($cellAddress = NULL, PHPExcel_Cell $pCell = NULL)
 {
     $cellAddress = PHPExcel_Calculation_Functions::flattenSingleValue($cellAddress);
     if (is_null($cellAddress) || $cellAddress === '') {
         return PHPExcel_Calculation_Functions::REF();
     }
     $cellAddress1 = $cellAddress;
     $cellAddress2 = NULL;
     if (strpos($cellAddress, ':') !== false) {
         list($cellAddress1, $cellAddress2) = explode(':', $cellAddress);
     }
     if (!preg_match('/^' . PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellAddress1, $matches) || !is_null($cellAddress2) && !preg_match('/^' . PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellAddress2, $matches)) {
         if (!preg_match('/^' . PHPExcel_Calculation::CALCULATION_REGEXP_NAMEDRANGE . '$/i', $cellAddress1, $matches)) {
             return PHPExcel_Calculation_Functions::REF();
         }
         if (strpos($cellAddress, '!') !== FALSE) {
             list($sheetName, $cellAddress) = explode('!', $cellAddress);
             $sheetName = trim($sheetName, "'");
             $pSheet = $pCell->getWorksheet()->getParent()->getSheetByName($sheetName);
         } else {
             $pSheet = $pCell->getWorksheet();
         }
         return PHPExcel_Calculation::getInstance()->extractNamedRange($cellAddress, $pSheet, FALSE);
     }
     if (strpos($cellAddress, '!') !== FALSE) {
         list($sheetName, $cellAddress) = explode('!', $cellAddress);
         $sheetName = trim($sheetName, "'");
         $pSheet = $pCell->getWorksheet()->getParent()->getSheetByName($sheetName);
     } else {
         $pSheet = $pCell->getWorksheet();
     }
     return PHPExcel_Calculation::getInstance()->extractCellRange($cellAddress, $pSheet, FALSE);
 }

 /**
  * Bind value to a cell
  *
  * @param  PHPExcel_Cell  $cell  Cell to bind value to
  * @param  mixed $value          Value to bind in cell
  * @return boolean
  */
 public function bindValue(PHPExcel_Cell $cell, $value = null)
 {
     // sanitize UTF-8 strings
     if (is_string($value)) {
         $value = PHPExcel_Shared_String::SanitizeUTF8($value);
     }
     // Find out data type
     $dataType = parent::dataTypeForValue($value);
     // Style logic - strings
     if ($dataType === PHPExcel_Cell_DataType::TYPE_STRING && !$value instanceof PHPExcel_RichText) {
         //    Test for booleans using locale-setting
         if ($value == PHPExcel_Calculation::getTRUE()) {
             $cell->setValueExplicit(TRUE, PHPExcel_Cell_DataType::TYPE_BOOL);
             return true;
         } elseif ($value == PHPExcel_Calculation::getFALSE()) {
             $cell->setValueExplicit(FALSE, PHPExcel_Cell_DataType::TYPE_BOOL);
             return true;
         }
         // Check for number in scientific format
         if (preg_match('/^' . PHPExcel_Calculation::CALCULATION_REGEXP_NUMBER . '$/', $value)) {
             $cell->setValueExplicit((double) $value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             return true;
         }
         // Check for fraction
         if (preg_match('/^([+-]?) *([0-9]*)\\s?\\/\\s*([0-9]*)$/', $value, $matches)) {
             // Convert value to number
             $value = $matches[2] / $matches[3];
             if ($matches[1] == '-') {
                 $value = 0 - $value;
             }
             $cell->setValueExplicit((double) $value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode('??/??');
             return true;
         } elseif (preg_match('/^([+-]?)([0-9]*) +([0-9]*)\\s?\\/\\s*([0-9]*)$/', $value, $matches)) {
             // Convert value to number
             $value = $matches[2] + $matches[3] / $matches[4];
             if ($matches[1] == '-') {
                 $value = 0 - $value;
             }
             $cell->setValueExplicit((double) $value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode('# ??/??');
             return true;
         }
         // Check for percentage
         if (preg_match('/^\\-?[0-9]*\\.?[0-9]*\\s?\\%$/', $value)) {
             // Convert value to number
             $value = (double) str_replace('%', '', $value) / 100;
             $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode(PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE_00);
             return true;
         }
         // Check for currency
         $currencyCode = PHPExcel_Shared_String::getCurrencyCode();
         $decimalSeparator = PHPExcel_Shared_String::getDecimalSeparator();
         $thousandsSeparator = PHPExcel_Shared_String::getThousandsSeparator();
         if (preg_match('/^' . preg_quote($currencyCode) . ' *(\\d{1,3}(' . preg_quote($thousandsSeparator) . '\\d{3})*|(\\d+))(' . preg_quote($decimalSeparator) . '\\d{2})?$/', $value)) {
             // Convert value to number
             $value = (double) trim(str_replace(array($currencyCode, $thousandsSeparator, $decimalSeparator), array('', '', '.'), $value));
             $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode(str_replace('$', $currencyCode, PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE));
             return true;
         } elseif (preg_match('/^\\$ *(\\d{1,3}(\\,\\d{3})*|(\\d+))(\\.\\d{2})?$/', $value)) {
             // Convert value to number
             $value = (double) trim(str_replace(array('$', ','), '', $value));
             $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode(PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE);
             return true;
         }
         // Check for time without seconds e.g. '9:45', '09:45'
         if (preg_match('/^(\\d|[0-1]\\d|2[0-3]):[0-5]\\d$/', $value)) {
             // Convert value to number
             list($h, $m) = explode(':', $value);
             $days = $h / 24 + $m / 1440;
             $cell->setValueExplicit($days, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode(PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME3);
             return true;
         }
         // Check for time with seconds '9:45:59', '09:45:59'
         if (preg_match('/^(\\d|[0-1]\\d|2[0-3]):[0-5]\\d:[0-5]\\d$/', $value)) {
             // Convert value to number
             list($h, $m, $s) = explode(':', $value);
             $days = $h / 24 + $m / 1440 + $s / 86400;
             // Convert value to number
             $cell->setValueExplicit($days, PHPExcel_Cell_DataType::TYPE_NUMERIC);
             // Set style
             $cell->getWorksheet()->getStyle($cell->getCoordinate())->getNumberFormat()->setFormatCode(PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4);
             return true;
//.........这里部分代码省略.........

 /**
  * Is a given cell a date/time?
  *
  * @param	 PHPExcel_Cell	$pCell
  * @return	 boolean
  */
 public static function isDateTime(PHPExcel_Cell $pCell)
 {
     return self::isDateTimeFormat($pCell->getWorksheet()->getStyle($pCell->getCoordinate())->getNumberFormat());
 }

 private function _parseFormula($formula, PHPExcel_Cell $pCell = null)
 {
     if (($formula = self::_convertMatrixReferences(trim($formula))) === false) {
         return false;
     }
     //	If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),
     //		so we store the parent worksheet so that we can re-attach it when necessary
     $pCellParent = $pCell !== null ? $pCell->getWorksheet() : null;
     $regexpMatchString = '/^(' . self::CALCULATION_REGEXP_FUNCTION . '|' . self::CALCULATION_REGEXP_CELLREF . '|' . self::CALCULATION_REGEXP_NUMBER . '|' . self::CALCULATION_REGEXP_STRING . '|' . self::CALCULATION_REGEXP_OPENBRACE . '|' . self::CALCULATION_REGEXP_NAMEDRANGE . '|' . self::CALCULATION_REGEXP_ERROR . ')/si';
     //	Start with initialisation
     $index = 0;
     $stack = new PHPExcel_Calculation_Token_Stack();
     $output = array();
     $expectingOperator = false;
     //	We use this test in syntax-checking the expression to determine when a
     //		- is a negation or + is a positive operator rather than an operation
     $expectingOperand = false;
     //	We use this test in syntax-checking the expression to determine whether an operand
     //		should be null in a function call
     //	The guts of the lexical parser
     //	Loop through the formula extracting each operator and operand in turn
     while (true) {
         //echo 'Assessing Expression '.substr($formula, $index),PHP_EOL;
         $opCharacter = $formula[$index];
         //	Get the first character of the value at the current index position
         //echo 'Initial character of expression block is '.$opCharacter,PHP_EOL;
         if (isset(self::$_comparisonOperators[$opCharacter]) && strlen($formula) > $index && isset(self::$_comparisonOperators[$formula[$index + 1]])) {
             $opCharacter .= $formula[++$index];
             //echo 'Initial character of expression block is comparison operator '.$opCharacter.PHP_EOL;
         }
         //	Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand
         $isOperandOrFunction = preg_match($regexpMatchString, substr($formula, $index), $match);
         //echo '$isOperandOrFunction is '.(($isOperandOrFunction) ? 'True' : 'False').PHP_EOL;
         //var_dump($match);
         if ($opCharacter == '-' && !$expectingOperator) {
             //	Is it a negation instead of a minus?
             //echo 'Element is a Negation operator',PHP_EOL;
             $stack->push('Unary Operator', '~');
             //	Put a negation on the stack
             ++$index;
             //		and drop the negation symbol
         } elseif ($opCharacter == '%' && $expectingOperator) {
             //echo 'Element is a Percentage operator',PHP_EOL;
             $stack->push('Unary Operator', '%');
             //	Put a percentage on the stack
             ++$index;
         } elseif ($opCharacter == '+' && !$expectingOperator) {
             //	Positive (unary plus rather than binary operator plus) can be discarded?
             //echo 'Element is a Positive number, not Plus operator',PHP_EOL;
             ++$index;
             //	Drop the redundant plus symbol
         } elseif (($opCharacter == '~' || $opCharacter == '|') && !$isOperandOrFunction) {
             //	We have to explicitly deny a tilde or pipe, because they are legal
             return $this->_raiseFormulaError("Formula Error: Illegal character '~'");
             //		on the stack but not in the input expression
         } elseif ((isset(self::$_operators[$opCharacter]) or $isOperandOrFunction) && $expectingOperator) {
             //	Are we putting an operator on the stack?
             //echo 'Element with value '.$opCharacter.' is an Operator',PHP_EOL;
             while ($stack->count() > 0 && ($o2 = $stack->last()) && isset(self::$_operators[$o2['value']]) && @(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {
                 $output[] = $stack->pop();
                 //	Swap operands and higher precedence operators from the stack to the output
             }
             $stack->push('Binary Operator', $opCharacter);
             //	Finally put our current operator onto the stack
             ++$index;
             $expectingOperator = false;
         } elseif ($opCharacter == ')' && $expectingOperator) {
             //	Are we expecting to close a parenthesis?
             //echo 'Element is a Closing bracket',PHP_EOL;
             $expectingOperand = false;
             while (($o2 = $stack->pop()) && $o2['value'] != '(') {
                 //	Pop off the stack back to the last (
                 if ($o2 === null) {
                     return $this->_raiseFormulaError('Formula Error: Unexpected closing brace ")"');
                 } else {
                     $output[] = $o2;
                 }
             }
             $d = $stack->last(2);
             if (preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/i', $d['value'], $matches)) {
                 //	Did this parenthesis just close a function?
                 $functionName = $matches[1];
                 //	Get the function name
                 //echo 'Closed Function is '.$functionName,PHP_EOL;
                 $d = $stack->pop();
                 $argumentCount = $d['value'];
                 //	See how many arguments there were (argument count is the next value stored on the stack)
                 //if ($argumentCount == 0) {
                 //	echo 'With no arguments',PHP_EOL;
                 //} elseif ($argumentCount == 1) {
                 //	echo 'With 1 argument',PHP_EOL;
                 //} else {
                 //	echo 'With '.$argumentCount.' arguments',PHP_EOL;
                 //}
                 $output[] = $d;
                 //	Dump the argument count on the output
                 $output[] = $stack->pop();
                 //	Pop the function and push onto the output
                 if (isset(self::$_controlFunctions[$functionName])) {
                     //echo 'Built-in function '.$functionName,PHP_EOL;
//.........这里部分代码省略.........