PHP PHPExcel_Calculation::getInstance方法代码示例

 /**
  * @dataProvider providerBinaryComparisonOperation
  */
 public function testBinaryComparisonOperation($formula, $expectedResultExcel, $expectedResultOpenOffice)
 {
     PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL);
     $resultExcel = \PHPExcel_Calculation::getInstance()->_calculateFormulaValue($formula);
     $this->assertEquals($expectedResultExcel, $resultExcel, 'should be Excel compatible');
     PHPExcel_Calculation_Functions::setCompatibilityMode(PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE);
     $resultOpenOffice = \PHPExcel_Calculation::getInstance()->_calculateFormulaValue($formula);
     $this->assertEquals($expectedResultOpenOffice, $resultOpenOffice, 'should be OpenOffice compatible');
 }

 /**
  * Save PHPExcel to file
  *
  * @param 	string 		$pFilename
  * @throws 	PHPExcel_Writer_Exception
  */
 public function save($pFilename = null)
 {
     if ($this->_spreadSheet !== NULL) {
         // garbage collect
         $this->_spreadSheet->garbageCollect();
         // If $pFilename is php://output or php://stdout, make it a temporary file...
         $originalFilename = $pFilename;
         if (strtolower($pFilename) == 'php://output' || strtolower($pFilename) == 'php://stdout') {
             $pFilename = @tempnam(PHPExcel_Shared_File::sys_get_temp_dir(), 'phpxltmp');
             if ($pFilename == '') {
                 $pFilename = $originalFilename;
             }
         }
         $saveDebugLog = PHPExcel_Calculation::getInstance($this->_spreadSheet)->getDebugLog()->getWriteDebugLog();
         PHPExcel_Calculation::getInstance($this->_spreadSheet)->getDebugLog()->setWriteDebugLog(FALSE);
         $saveDateReturnType = PHPExcel_Calculation_Functions::getReturnDateType();
         PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
         // Create string lookup table
         $this->_stringTable = array();
         for ($i = 0; $i < $this->_spreadSheet->getSheetCount(); ++$i) {
             $this->_stringTable = $this->getWriterPart('StringTable')->createStringTable($this->_spreadSheet->getSheet($i), $this->_stringTable);
         }
         // Create styles dictionaries
         $this->_styleHashTable->addFromSource($this->getWriterPart('Style')->allStyles($this->_spreadSheet));
         $this->_stylesConditionalHashTable->addFromSource($this->getWriterPart('Style')->allConditionalStyles($this->_spreadSheet));
         $this->_fillHashTable->addFromSource($this->getWriterPart('Style')->allFills($this->_spreadSheet));
         $this->_fontHashTable->addFromSource($this->getWriterPart('Style')->allFonts($this->_spreadSheet));
         $this->_bordersHashTable->addFromSource($this->getWriterPart('Style')->allBorders($this->_spreadSheet));
         $this->_numFmtHashTable->addFromSource($this->getWriterPart('Style')->allNumberFormats($this->_spreadSheet));
         // Create drawing dictionary
         $this->_drawingHashTable->addFromSource($this->getWriterPart('Drawing')->allDrawings($this->_spreadSheet));
         // Create new ZIP file and open it for writing
         $zipClass = PHPExcel_Settings::getZipClass();
         $objZip = new $zipClass();
         //	Retrieve OVERWRITE and CREATE constants from the instantiated zip class
         //	This method of accessing constant values from a dynamic class should work with all appropriate versions of PHP
         $ro = new ReflectionObject($objZip);
         $zipOverWrite = $ro->getConstant('OVERWRITE');
         $zipCreate = $ro->getConstant('CREATE');
         if (file_exists($pFilename)) {
             unlink($pFilename);
         }
         // Try opening the ZIP file
         if ($objZip->open($pFilename, $zipOverWrite) !== true) {
             if ($objZip->open($pFilename, $zipCreate) !== true) {
                 throw new PHPExcel_Writer_Exception("Could not open " . $pFilename . " for writing.");
             }
         }
         // Add [Content_Types].xml to ZIP file
         $objZip->addFromString('[Content_Types].xml', $this->getWriterPart('ContentTypes')->writeContentTypes($this->_spreadSheet, $this->_includeCharts));
         //if hasMacros, add the vbaProject.bin file, Certificate file(if exists)
         if ($this->_spreadSheet->hasMacros()) {
             $macrosCode = $this->_spreadSheet->getMacrosCode();
             if (!is_null($macrosCode)) {
                 // we have the code ?
                 $objZip->addFromString('xl/vbaProject.bin', $macrosCode);
                 //allways in 'xl', allways named vbaProject.bin
                 if ($this->_spreadSheet->hasMacrosCertificate()) {
                     //signed macros ?
                     // Yes : add the certificate file and the related rels file
                     $objZip->addFromString('xl/vbaProjectSignature.bin', $this->_spreadSheet->getMacrosCertificate());
                     $objZip->addFromString('xl/_rels/vbaProject.bin.rels', $this->getWriterPart('RelsVBA')->writeVBARelationships($this->_spreadSheet));
                 }
             }
         }
         //a custom UI in this workbook ? add it ("base" xml and additional objects (pictures) and rels)
         if ($this->_spreadSheet->hasRibbon()) {
             $tmpRibbonTarget = $this->_spreadSheet->getRibbonXMLData('target');
             $objZip->addFromString($tmpRibbonTarget, $this->_spreadSheet->getRibbonXMLData('data'));
             if ($this->_spreadSheet->hasRibbonBinObjects()) {
                 $tmpRootPath = dirname($tmpRibbonTarget) . '/';
                 $ribbonBinObjects = $this->_spreadSheet->getRibbonBinObjects('data');
                 //the files to write
                 foreach ($ribbonBinObjects as $aPath => $aContent) {
                     $objZip->addFromString($tmpRootPath . $aPath, $aContent);
                 }
                 //the rels for files
                 $objZip->addFromString($tmpRootPath . '_rels/' . basename($tmpRibbonTarget) . '.rels', $this->getWriterPart('RelsRibbonObjects')->writeRibbonRelationships($this->_spreadSheet));
             }
         }
         // Add relationships to ZIP file
         $objZip->addFromString('_rels/.rels', $this->getWriterPart('Rels')->writeRelationships($this->_spreadSheet));
         $objZip->addFromString('xl/_rels/workbook.xml.rels', $this->getWriterPart('Rels')->writeWorkbookRelationships($this->_spreadSheet));
         // Add document properties to ZIP file
         $objZip->addFromString('docProps/app.xml', $this->getWriterPart('DocProps')->writeDocPropsApp($this->_spreadSheet));
         $objZip->addFromString('docProps/core.xml', $this->getWriterPart('DocProps')->writeDocPropsCore($this->_spreadSheet));
         $customPropertiesPart = $this->getWriterPart('DocProps')->writeDocPropsCustom($this->_spreadSheet);
         if ($customPropertiesPart !== NULL) {
             $objZip->addFromString('docProps/custom.xml', $customPropertiesPart);
         }
         // Add theme to ZIP file
         $objZip->addFromString('xl/theme/theme1.xml', $this->getWriterPart('Theme')->writeTheme($this->_spreadSheet));
         // Add string table to ZIP file
         $objZip->addFromString('xl/sharedStrings.xml', $this->getWriterPart('StringTable')->writeStringTable($this->_stringTable));
//.........这里部分代码省略.........

 /**
  * SUMIF
  *
  * Counts the number of cells that contain numbers within the list of arguments
  *
  * Excel Function:
  *		SUMIF(value1[,value2[, ...]],condition)
  *
  * @access	public
  * @category Mathematical and Trigonometric Functions
  * @param	mixed		$arg,...		Data values
  * @param	string		$condition		The criteria that defines which cells will be summed.
  * @return	float
  */
 public static function SUMIF($aArgs, $condition, $sumArgs = array())
 {
     // Return value
     $returnValue = 0;
     $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
     $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
     if (empty($sumArgs)) {
         $sumArgs = $aArgs;
     }
     $condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
     // Loop through arguments
     foreach ($aArgs as $key => $arg) {
         if (!is_numeric($arg)) {
             $arg = str_replace('"', '""', $arg);
             $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg));
         }
         $testCondition = '=' . $arg . $condition;
         if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
             // Is it a value within our criteria
             $returnValue += $sumArgs[$key];
         }
     }
     // Return
     return $returnValue;
 }

 /**
  *	Get calculated cell value
  *
  *	@deprecated		Since version 1.7.8 for planned changes to cell for array formula handling
  *
  *	@param	boolean $resetLog  Whether the calculation engine logger should be reset or not
  *	@return	mixed
  *	@throws	PHPExcel_Exception
  */
 public function getCalculatedValue($resetLog = true)
 {
     if ($this->_dataType == PHPExcel_Cell_DataType::TYPE_FORMULA) {
         try {
             $result = PHPExcel_Calculation::getInstance($this->getWorksheet()->getParent())->calculateCellValue($this, $resetLog);
             //	We don't yet handle array returns
             if (is_array($result)) {
                 while (is_array($result)) {
                     $result = array_pop($result);
                 }
             }
         } catch (PHPExcel_Exception $ex) {
             if ($ex->getMessage() === 'Unable to access External Workbook' && $this->_calculatedValue !== null) {
                 return $this->_calculatedValue;
                 // Fallback for calculations referencing external files.
             }
             $result = '#N/A';
             throw new PHPExcel_Calculation_Exception($this->getWorksheet()->getTitle() . '!' . $this->getCoordinate() . ' -> ' . $ex->getMessage());
         }
         if ($result === '#Not Yet Implemented') {
             return $this->_calculatedValue;
             // Fallback if calculation engine does not support the formula.
         }
         return $result;
     } elseif ($this->_value instanceof PHPExcel_RichText) {
         return $this->_value->getPlainText();
     }
     return $this->_value;
 }

 /**
  * Save PHPExcel to file
  *
  * @param    string $pFilename
  *
  * @throws    PHPExcel_Writer_Exception
  */
 public function save($pFilename = null)
 {
     // garbage collect
     $this->_phpExcel->garbageCollect();
     $saveDebugLog = PHPExcel_Calculation::getInstance($this->_phpExcel)->getDebugLog()->getWriteDebugLog();
     PHPExcel_Calculation::getInstance($this->_phpExcel)->getDebugLog()->setWriteDebugLog(false);
     $saveDateReturnType = PHPExcel_Calculation_Functions::getReturnDateType();
     PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
     // initialize colors array
     $this->_colors = array();
     // Initialise workbook writer
     $this->_writerWorkbook = new PHPExcel_Writer_Excel5_Workbook($this->_phpExcel, $this->_str_total, $this->_str_unique, $this->_str_table, $this->_colors, $this->_parser);
     // Initialise worksheet writers
     $countSheets = $this->_phpExcel->getSheetCount();
     for ($i = 0; $i < $countSheets; ++$i) {
         $this->_writerWorksheets[$i] = new PHPExcel_Writer_Excel5_Worksheet($this->_str_total, $this->_str_unique, $this->_str_table, $this->_colors, $this->_parser, $this->_preCalculateFormulas, $this->_phpExcel->getSheet($i));
     }
     // build Escher objects. Escher objects for workbooks needs to be build before Escher object for workbook.
     $this->_buildWorksheetEschers();
     $this->_buildWorkbookEscher();
     // add 15 identical cell style Xfs
     // for now, we use the first cellXf instead of cellStyleXf
     $cellXfCollection = $this->_phpExcel->getCellXfCollection();
     for ($i = 0; $i < 15; ++$i) {
         $this->_writerWorkbook->addXfWriter($cellXfCollection[0], true);
     }
     // add all the cell Xfs
     foreach ($this->_phpExcel->getCellXfCollection() as $style) {
         $this->_writerWorkbook->addXfWriter($style, false);
     }
     // add fonts from rich text eleemnts
     for ($i = 0; $i < $countSheets; ++$i) {
         foreach ($this->_writerWorksheets[$i]->_phpSheet->getCellCollection() as $cellID) {
             $cell = $this->_writerWorksheets[$i]->_phpSheet->getCell($cellID);
             $cVal = $cell->getValue();
             if ($cVal instanceof PHPExcel_RichText) {
                 $elements = $cVal->getRichTextElements();
                 foreach ($elements as $element) {
                     if ($element instanceof PHPExcel_RichText_Run) {
                         $font = $element->getFont();
                         $this->_writerWorksheets[$i]->_fntHashIndex[$font->getHashCode()] = $this->_writerWorkbook->_addFont($font);
                     }
                 }
             }
         }
     }
     // initialize OLE file
     $workbookStreamName = 'Workbook';
     $OLE = new PHPExcel_Shared_OLE_PPS_File(PHPExcel_Shared_OLE::Asc2Ucs($workbookStreamName));
     // Write the worksheet streams before the global workbook stream,
     // because the byte sizes of these are needed in the global workbook stream
     $worksheetSizes = array();
     for ($i = 0; $i < $countSheets; ++$i) {
         $this->_writerWorksheets[$i]->close();
         $worksheetSizes[] = $this->_writerWorksheets[$i]->_datasize;
     }
     // add binary data for global workbook stream
     $OLE->append($this->_writerWorkbook->writeWorkbook($worksheetSizes));
     // add binary data for sheet streams
     for ($i = 0; $i < $countSheets; ++$i) {
         $OLE->append($this->_writerWorksheets[$i]->getData());
     }
     $this->_documentSummaryInformation = $this->_writeDocumentSummaryInformation();
     // initialize OLE Document Summary Information
     if (isset($this->_documentSummaryInformation) && !empty($this->_documentSummaryInformation)) {
         $OLE_DocumentSummaryInformation = new PHPExcel_Shared_OLE_PPS_File(PHPExcel_Shared_OLE::Asc2Ucs(chr(5) . 'DocumentSummaryInformation'));
         $OLE_DocumentSummaryInformation->append($this->_documentSummaryInformation);
     }
     $this->_summaryInformation = $this->_writeSummaryInformation();
     // initialize OLE Summary Information
     if (isset($this->_summaryInformation) && !empty($this->_summaryInformation)) {
         $OLE_SummaryInformation = new PHPExcel_Shared_OLE_PPS_File(PHPExcel_Shared_OLE::Asc2Ucs(chr(5) . 'SummaryInformation'));
         $OLE_SummaryInformation->append($this->_summaryInformation);
     }
     // define OLE Parts
     $arrRootData = array($OLE);
     // initialize OLE Properties file
     if (isset($OLE_SummaryInformation)) {
         $arrRootData[] = $OLE_SummaryInformation;
     }
     // initialize OLE Extended Properties file
     if (isset($OLE_DocumentSummaryInformation)) {
         $arrRootData[] = $OLE_DocumentSummaryInformation;
     }
     $root = new PHPExcel_Shared_OLE_PPS_Root(time(), time(), $arrRootData);
     // save the OLE file
     $res = $root->save($pFilename);
     PHPExcel_Calculation_Functions::setReturnDateType($saveDateReturnType);
     PHPExcel_Calculation::getInstance($this->_phpExcel)->getDebugLog()->setWriteDebugLog($saveDebugLog);
 }

 /**
  * Save PHPExcel to file
  *
  * @param	string		$pFileName
  * @throws	Exception
  */
 public function save($pFilename = null)
 {
     // garbage collect
     $this->_phpExcel->garbageCollect();
     $saveDebugLog = PHPExcel_Calculation::getInstance()->writeDebugLog;
     PHPExcel_Calculation::getInstance()->writeDebugLog = false;
     $saveDateReturnType = PHPExcel_Calculation_Functions::getReturnDateType();
     PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
     // initialize colors array
     $this->_colors = array();
     // Initialise workbook writer
     $this->_writerWorkbook = new PHPExcel_Writer_Excel5_Workbook($this->_phpExcel, $this->_BIFF_version, $this->_str_total, $this->_str_unique, $this->_str_table, $this->_colors, $this->_parser);
     // Initialise worksheet writers
     $countSheets = $this->_phpExcel->getSheetCount();
     for ($i = 0; $i < $countSheets; ++$i) {
         $this->_writerWorksheets[$i] = new PHPExcel_Writer_Excel5_Worksheet($this->_BIFF_version, $this->_str_total, $this->_str_unique, $this->_str_table, $this->_colors, $this->_parser, $this->_preCalculateFormulas, $this->_phpExcel->getSheet($i));
     }
     // build Escher objects. Escher objects for workbooks needs to be build before Escher object for workbook.
     $this->_buildWorksheetEschers();
     $this->_buildWorkbookEscher();
     // add 15 identical cell style Xfs
     // for now, we use the first cellXf instead of cellStyleXf
     $cellXfCollection = $this->_phpExcel->getCellXfCollection();
     for ($i = 0; $i < 15; ++$i) {
         $this->_writerWorkbook->addXfWriter($cellXfCollection[0], true);
     }
     // add all the cell Xfs
     foreach ($this->_phpExcel->getCellXfCollection() as $style) {
         $this->_writerWorkbook->addXfWriter($style, false);
     }
     // initialize OLE file
     $workbookStreamName = $this->_BIFF_version == 0x600 ? 'Workbook' : 'Book';
     $OLE = new PHPExcel_Shared_OLE_PPS_File(PHPExcel_Shared_OLE::Asc2Ucs($workbookStreamName));
     // Write the worksheet streams before the global workbook stream,
     // because the byte sizes of these are needed in the global workbook stream
     $worksheetSizes = array();
     for ($i = 0; $i < $countSheets; ++$i) {
         $this->_writerWorksheets[$i]->close();
         $worksheetSizes[] = $this->_writerWorksheets[$i]->_datasize;
     }
     // add binary data for global workbook stream
     $OLE->append($this->_writerWorkbook->writeWorkbook($worksheetSizes));
     // add binary data for sheet streams
     for ($i = 0; $i < $countSheets; ++$i) {
         $OLE->append($this->_writerWorksheets[$i]->getData());
     }
     $root = new PHPExcel_Shared_OLE_PPS_Root(time(), time(), array($OLE));
     // save the OLE file
     $res = $root->save($pFilename);
     PHPExcel_Calculation_Functions::setReturnDateType($saveDateReturnType);
     PHPExcel_Calculation::getInstance()->writeDebugLog = $saveDebugLog;
 }

 /**
  * Get caluclated cell value
  *
  * @return mixed
  */
 public function getCalculatedValue()
 {
     if (is_null($this->_value) || $this->_value === '') {
         return '';
     } else {
         if ($this->_dataType != PHPExcel_Cell_DataType::TYPE_FORMULA) {
             return $this->_value;
         } else {
             return PHPExcel_Calculation::getInstance()->calculate($this);
         }
     }
 }

 public function refresh(PHPExcel_Worksheet $worksheet, $flatten = TRUE)
 {
     if ($this->_dataSource !== NULL) {
         $calcEngine = PHPExcel_Calculation::getInstance();
         $newDataValues = PHPExcel_Calculation::_unwrapResult($calcEngine->_calculateFormulaValue('=' . $this->_dataSource, NULL, $worksheet->getCell('A1')));
         if ($flatten) {
             $this->_dataValues = PHPExcel_Calculation_Functions::flattenArray($newDataValues);
         } else {
             $newArray = array_values(array_shift($newDataValues));
             foreach ($newArray as $i => $newDataSet) {
                 $newArray[$i] = array($newDataSet);
             }
             foreach ($newDataValues as $newDataSet) {
                 $i = 0;
                 foreach ($newDataSet as $newDataVal) {
                     array_unshift($newArray[$i++], $newDataVal);
                 }
             }
             $this->_dataValues = $newArray;
         }
         $this->_pointCount = count($this->_dataValues);
     }
 }

 public function refresh(PHPExcel_Worksheet $worksheet, $flatten = TRUE)
 {
     if ($this->_dataSource !== NULL) {
         $calcEngine = PHPExcel_Calculation::getInstance($worksheet->getParent());
         $newDataValues = PHPExcel_Calculation::_unwrapResult($calcEngine->_calculateFormulaValue('=' . $this->_dataSource, NULL, $worksheet->getCell('A1')));
         if ($flatten) {
             $this->_dataValues = PHPExcel_Calculation_Functions::flattenArray($newDataValues);
             foreach ($this->_dataValues as &$dataValue) {
                 if (!empty($dataValue) && $dataValue[0] == '#') {
                     $dataValue = 0.0;
                 }
             }
             unset($dataValue);
         } else {
             $cellRange = explode('!', $this->_dataSource);
             if (count($cellRange) > 1) {
                 list(, $cellRange) = $cellRange;
             }
             $dimensions = PHPExcel_Cell::rangeDimension(str_replace('$', '', $cellRange));
             if ($dimensions[0] == 1 || $dimensions[1] == 1) {
                 $this->_dataValues = PHPExcel_Calculation_Functions::flattenArray($newDataValues);
             } else {
                 $newArray = array_values(array_shift($newDataValues));
                 foreach ($newArray as $i => $newDataSet) {
                     $newArray[$i] = array($newDataSet);
                 }
                 foreach ($newDataValues as $newDataSet) {
                     $i = 0;
                     foreach ($newDataSet as $newDataVal) {
                         array_unshift($newArray[$i++], $newDataVal);
                     }
                 }
                 $this->_dataValues = $newArray;
             }
         }
         $this->_pointCount = count($this->_dataValues);
     }
 }

 public function refresh(PHPExcel_Worksheet $worksheet)
 {
     if ($this->_dataSource !== NULL) {
         $calcEngine = PHPExcel_Calculation::getInstance();
         $newDataValues = PHPExcel_Calculation::_unwrapResult($calcEngine->_calculateFormulaValue('=' . $this->_dataSource, NULL, $worksheet->getCell('A1')));
         $this->_dataValues = PHPExcel_Calculation_Functions::flattenArray($newDataValues);
     }
 }

 /**
  *	Apply the AutoFilter rules to the AutoFilter Range
  *
  *	@throws	PHPExcel_Exception
  *	@return PHPExcel_Worksheet_AutoFilter
  */
 public function showHideRows()
 {
     list($rangeStart, $rangeEnd) = PHPExcel_Cell::rangeBoundaries($this->_range);
     //	The heading row should always be visible
     //		echo 'AutoFilter Heading Row ',$rangeStart[1],' is always SHOWN',PHP_EOL;
     $this->_workSheet->getRowDimension($rangeStart[1])->setVisible(TRUE);
     $columnFilterTests = array();
     foreach ($this->_columns as $columnID => $filterColumn) {
         $rules = $filterColumn->getRules();
         switch ($filterColumn->getFilterType()) {
             case PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_FILTER:
                 $ruleValues = array();
                 //	Build a list of the filter value selections
                 foreach ($rules as $rule) {
                     $ruleType = $rule->getRuleType();
                     $ruleValues[] = $rule->getValue();
                 }
                 //	Test if we want to include blanks in our filter criteria
                 $blanks = FALSE;
                 $ruleDataSet = array_filter($ruleValues);
                 if (count($ruleValues) != count($ruleDataSet)) {
                     $blanks = TRUE;
                 }
                 if ($ruleType == PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_FILTER) {
                     //	Filter on absolute values
                     $columnFilterTests[$columnID] = array('method' => '_filterTestInSimpleDataSet', 'arguments' => array('filterValues' => $ruleDataSet, 'blanks' => $blanks));
                 } else {
                     //	Filter on date group values
                     $arguments = array('date' => array(), 'time' => array(), 'dateTime' => array());
                     foreach ($ruleDataSet as $ruleValue) {
                         $date = $time = '';
                         if (isset($ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_YEAR]) && $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_YEAR] !== '') {
                             $date .= sprintf('%04d', $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_YEAR]);
                         }
                         if (isset($ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MONTH]) && $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MONTH] != '') {
                             $date .= sprintf('%02d', $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MONTH]);
                         }
                         if (isset($ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_DAY]) && $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_DAY] !== '') {
                             $date .= sprintf('%02d', $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_DAY]);
                         }
                         if (isset($ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_HOUR]) && $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_HOUR] !== '') {
                             $time .= sprintf('%02d', $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_HOUR]);
                         }
                         if (isset($ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MINUTE]) && $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MINUTE] !== '') {
                             $time .= sprintf('%02d', $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_MINUTE]);
                         }
                         if (isset($ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_SECOND]) && $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_SECOND] !== '') {
                             $time .= sprintf('%02d', $ruleValue[PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP_SECOND]);
                         }
                         $dateTime = $date . $time;
                         $arguments['date'][] = $date;
                         $arguments['time'][] = $time;
                         $arguments['dateTime'][] = $dateTime;
                     }
                     //	Remove empty elements
                     $arguments['date'] = array_filter($arguments['date']);
                     $arguments['time'] = array_filter($arguments['time']);
                     $arguments['dateTime'] = array_filter($arguments['dateTime']);
                     $columnFilterTests[$columnID] = array('method' => '_filterTestInDateGroupSet', 'arguments' => array('filterValues' => $arguments, 'blanks' => $blanks));
                 }
                 break;
             case PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_CUSTOMFILTER:
                 $customRuleForBlanks = FALSE;
                 $ruleValues = array();
                 //	Build a list of the filter value selections
                 foreach ($rules as $rule) {
                     $ruleType = $rule->getRuleType();
                     $ruleValue = $rule->getValue();
                     if (!is_numeric($ruleValue)) {
                         //	Convert to a regexp allowing for regexp reserved characters, wildcards and escaped wildcards
                         $ruleValue = preg_quote($ruleValue);
                         $ruleValue = str_replace(self::$_fromReplace, self::$_toReplace, $ruleValue);
                         if (trim($ruleValue) == '') {
                             $customRuleForBlanks = TRUE;
                             $ruleValue = trim($ruleValue);
                         }
                     }
                     $ruleValues[] = array('operator' => $rule->getOperator(), 'value' => $ruleValue);
                 }
                 $join = $filterColumn->getJoin();
                 $columnFilterTests[$columnID] = array('method' => '_filterTestInCustomDataSet', 'arguments' => array('filterRules' => $ruleValues, 'join' => $join, 'customRuleForBlanks' => $customRuleForBlanks));
                 break;
             case PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_DYNAMICFILTER:
                 $ruleValues = array();
                 foreach ($rules as $rule) {
                     //	We should only ever have one Dynamic Filter Rule anyway
                     $dynamicRuleType = $rule->getGrouping();
                     if ($dynamicRuleType == PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DYNAMIC_ABOVEAVERAGE || $dynamicRuleType == PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DYNAMIC_BELOWAVERAGE) {
                         //	Number (Average) based
                         //	Calculate the average
                         $averageFormula = '=AVERAGE(' . $columnID . ($rangeStart[1] + 1) . ':' . $columnID . $rangeEnd[1] . ')';
                         $average = PHPExcel_Calculation::getInstance()->calculateFormula($averageFormula, NULL, $this->_workSheet->getCell('A1'));
                         //	Set above/below rule based on greaterThan or LessTan
                         $operator = $dynamicRuleType === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DYNAMIC_ABOVEAVERAGE ? PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_GREATERTHAN : PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_LESSTHAN;
//.........这里部分代码省略.........

 /**
  *    Get calculated cell value
  *
  * @deprecated        Since version 1.7.8 for planned changes to cell for array formula handling
  *
  * @param    boolean $resetLog Whether the calculation engine logger should be reset or not
  *
  * @return    mixed
  * @throws    PHPExcel_Exception
  */
 public function getCalculatedValue($resetLog = true)
 {
     //echo 'Cell '.$this->getCoordinate().' value is a '.$this->_dataType.' with a value of '.$this->getValue().PHP_EOL;
     if ($this->_dataType == PHPExcel_Cell_DataType::TYPE_FORMULA) {
         try {
             //echo 'Cell value for '.$this->getCoordinate().' is a formula: Calculating value'.PHP_EOL;
             $result = PHPExcel_Calculation::getInstance($this->getWorksheet()->getParent())->calculateCellValue($this, $resetLog);
             //echo $this->getCoordinate().' calculation result is '.$result.PHP_EOL;
             //	We don't yet handle array returns
             if (is_array($result)) {
                 while (is_array($result)) {
                     $result = array_pop($result);
                 }
             }
         } catch (PHPExcel_Exception $ex) {
             if ($ex->getMessage() === 'Unable to access External Workbook' && $this->_calculatedValue !== null) {
                 //echo 'Returning fallback value of '.$this->_calculatedValue.' for cell '.$this->getCoordinate().PHP_EOL;
                 return $this->_calculatedValue;
                 // Fallback for calculations referencing external files.
             }
             //echo 'Calculation Exception: '.$ex->getMessage().PHP_EOL;
             $result = '#N/A';
             throw new PHPExcel_Calculation_Exception($this->getWorksheet()->getTitle() . '!' . $this->getCoordinate() . ' -> ' . $ex->getMessage());
         }
         if ($result === '#Not Yet Implemented') {
             //echo 'Returning fallback value of '.$this->_calculatedValue.' for cell '.$this->getCoordinate().PHP_EOL;
             return $this->_calculatedValue;
             // Fallback if calculation engine does not support the formula.
         }
         //echo 'Returning calculated value of '.$result.' for cell '.$this->getCoordinate().PHP_EOL;
         return $result;
     } elseif ($this->_value instanceof PHPExcel_RichText) {
         //		echo 'Cell value for '.$this->getCoordinate().' is rich text: Returning data value of '.$this->_value.'<br />';
         return $this->_value->getPlainText();
     }
     //		echo 'Cell value for '.$this->getCoordinate().' is not a formula: Returning data value of '.$this->_value.'<br />';
     return $this->_value;
 }

 /**
  *	MINIF
  *
  *	Returns the minimum value within a range of cells that contain numbers within the list of arguments
  *
  *	Excel Function:
  *		MINIF(value1[,value2[, ...]],condition)
  *
  *	@access	public
  *	@category Mathematical and Trigonometric Functions
  *	@param	mixed		$arg,...		Data values
  *	@param	string		$condition		The criteria that defines which cells will be checked.
  *	@return	float
  */
 public static function MINIF($aArgs, $condition, $sumArgs = array())
 {
     // Return value
     $returnValue = null;
     $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
     $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
     if (count($sumArgs) == 0) {
         $sumArgs = $aArgs;
     }
     $condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
     // Loop through arguments
     foreach ($aArgs as $key => $arg) {
         if (!is_numeric($arg)) {
             $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg));
         }
         $testCondition = '=' . $arg . $condition;
         if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
             if (is_null($returnValue) || $arg < $returnValue) {
                 $returnValue = $arg;
             }
         }
     }
     // Return
     return $returnValue;
 }

 /**
  * Save PHPExcel to file
  *
  * @param	string		$pFilename
  * @throws	PHPExcel_Writer_Exception
  */
 public function save($pFilename = null)
 {
     // garbage collect
     $this->_phpExcel->garbageCollect();
     $saveDebugLog = PHPExcel_Calculation::getInstance($this->_phpExcel)->getDebugLog()->getWriteDebugLog();
     PHPExcel_Calculation::getInstance($this->_phpExcel)->getDebugLog()->setWriteDebugLog(FALSE);
     $saveArrayReturnType = PHPExcel_Calculation::getArrayReturnType();
     PHPExcel_Calculation::setArrayReturnType(PHPExcel_Calculation::RETURN_ARRAY_AS_VALUE);
     // Build CSS
     $this->buildCSS(!$this->_useInlineCss);
     // Open file
     $fileHandle = fopen($pFilename, 'wb+');
     if ($fileHandle === false) {
         throw new PHPExcel_Writer_Exception("Could not open file {$pFilename} for writing.");
     }
     // Write headers
     fwrite($fileHandle, $this->generateHTMLHeader(!$this->_useInlineCss));
     // Write navigation (tabs)
     if (!$this->_isPdf && $this->_generateSheetNavigationBlock) {
         fwrite($fileHandle, $this->generateNavigation());
     }
     // Write data
     fwrite($fileHandle, $this->generateSheetData());
     // Write footer
     fwrite($fileHandle, $this->generateHTMLFooter());
     // Close file
     fclose($fileHandle);
     PHPExcel_Calculation::setArrayReturnType($saveArrayReturnType);
     PHPExcel_Calculation::getInstance($this->_phpExcel)->getDebugLog()->setWriteDebugLog($saveDebugLog);
 }

 /**
  * Create a new PHPExcel with one Worksheet
  */
 public function __construct()
 {
     $this->uniqueID = uniqid();
     $this->calculationEngine = PHPExcel_Calculation::getInstance($this);
     // Initialise worksheet collection and add one worksheet
     $this->workSheetCollection = array();
     $this->workSheetCollection[] = new PHPExcel_Worksheet($this);
     $this->activeSheetIndex = 0;
     // Create document properties
     $this->properties = new PHPExcel_DocumentProperties();
     // Create document security
     $this->security = new PHPExcel_DocumentSecurity();
     // Set named ranges
     $this->namedRanges = array();
     // Create the cellXf supervisor
     $this->cellXfSupervisor = new PHPExcel_Style(true);
     $this->cellXfSupervisor->bindParent($this);
     // Create the default style
     $this->addCellXf(new PHPExcel_Style());
     $this->addCellStyleXf(new PHPExcel_Style());
 }