PHP PHPExcel_Shared_File::sys_get_temp_dir方法代码示例

	public function open($fileName) {
		$this->_tempDir = PHPExcel_Shared_File::sys_get_temp_dir ();
		
		$this->_zip = new PclZip ( $fileName );
		
		return true;
	}

 /**
  * Initialise this new cell collection
  *
  * @param    PHPExcel_Worksheet $parent The worksheet for this cell collection
  * @param                       array   of mixed        $arguments    Additional initialisation arguments
  */
 public function __construct(PHPExcel_Worksheet $parent, $arguments)
 {
     $this->_cacheDirectory = isset($arguments['dir']) && $arguments['dir'] !== null ? $arguments['dir'] : PHPExcel_Shared_File::sys_get_temp_dir();
     parent::__construct($parent);
     if (is_null($this->_fileHandle)) {
         $baseUnique = $this->_getUniqueID();
         $this->_fileName = $this->_cacheDirectory . '/PHPExcel.' . $baseUnique . '.cache';
         $this->_fileHandle = fopen($this->_fileName, 'a+');
     }
 }

	/**
	 * @param integer $time_1st A timestamp
	 * @param integer $time_2nd A timestamp
	 */
	public function __construct($time_1st, $time_2nd, $raChild)
	{
		$this->_tempDir = PHPExcel_Shared_File::sys_get_temp_dir();

		parent::__construct(
		   null,
		   PHPExcel_Shared_OLE::Asc2Ucs('Root Entry'),
		   PHPExcel_Shared_OLE::OLE_PPS_TYPE_ROOT,
		   null,
		   null,
		   null,
		   $time_1st,
		   $time_2nd,
		   null,
		   $raChild);
	}

 /**
  * Method for saving the whole OLE container (including files).
  * In fact, if called with an empty argument (or '-'), it saves to a
  * temporary file and then outputs it's contents to stdout.
  * If a resource pointer to a stream created by fopen() is passed
  * it will be used, but you have to close such stream by yourself.
  *
  * @param string|resource $filename The name of the file or stream where to save the OLE container.
  *
  * @access public
  * @return mixed true on success
  */
 public function save($filename)
 {
     // Initial Setting for saving
     $this->_BIG_BLOCK_SIZE = pow(2, isset($this->_BIG_BLOCK_SIZE) ? self::_adjust2($this->_BIG_BLOCK_SIZE) : 9);
     $this->_SMALL_BLOCK_SIZE = pow(2, isset($this->_SMALL_BLOCK_SIZE) ? self::_adjust2($this->_SMALL_BLOCK_SIZE) : 6);
     if (is_resource($filename)) {
         $this->_FILEH_ = $filename;
     } else {
         if ($filename == '-' || $filename == '') {
             if ($this->_tmp_dir === null) {
                 $this->_tmp_dir = PHPExcel_Shared_File::sys_get_temp_dir();
             }
             $this->_tmp_filename = tempnam($this->_tmp_dir, "OLE_PPS_Root");
             $this->_FILEH_ = fopen($this->_tmp_filename, "w+b");
             if ($this->_FILEH_ == false) {
                 throw new PHPExcel_Writer_Exception("Can't create temporary file.");
             }
         } else {
             $this->_FILEH_ = fopen($filename, "wb");
         }
     }
     if ($this->_FILEH_ == false) {
         throw new PHPExcel_Writer_Exception("Can't open {$filename}. It may be in use or protected.");
     }
     // Make an array of PPS's (for Save)
     $aList = array();
     PHPExcel_Shared_OLE_PPS::_savePpsSetPnt($aList, array($this));
     // calculate values for header
     list($iSBDcnt, $iBBcnt, $iPPScnt) = $this->_calcSize($aList);
     //, $rhInfo);
     // Save Header
     $this->_saveHeader($iSBDcnt, $iBBcnt, $iPPScnt);
     // Make Small Data string (write SBD)
     $this->_data = $this->_makeSmallData($aList);
     // Write BB
     $this->_saveBigData($iSBDcnt, $aList);
     // Write PPS
     $this->_savePps($aList);
     // Write Big Block Depot and BDList and Adding Header informations
     $this->_saveBbd($iSBDcnt, $iBBcnt, $iPPScnt);
     if (!is_resource($filename)) {
         fclose($this->_FILEH_);
     }
     return true;
 }

 /**
  * Dumps the stats table
  * @param  StatsTable $statsTable
  * @return string
  */
 public function dump(StatsTable $statsTable)
 {
     $excel = new \PHPExcel();
     $excel->getDefaultStyle()->applyFromArray($this->getDefaultStyleArray());
     $sheet = $excel->getSheet();
     $row = 1;
     $data = $statsTable->getData();
     $width = count(reset($data));
     // HEADERS //
     if ($this->enableHeaders) {
         $headerStyle = new \PHPExcel_Style();
         $headerStyle->applyFromArray($this->getHeadersStyleArray());
         $col = 0;
         foreach ($statsTable->getHeaders() as $header) {
             $sheet->setCellValueByColumnAndRow($col, $row, $header);
             $col++;
         }
         $sheet->duplicateStyle($headerStyle, 'A1:' . \PHPExcel_Cell::stringFromColumnIndex($width - 1) . '1');
         $row++;
     }
     // DATA //
     foreach ($statsTable->getData() as $data) {
         $this->applyValues($sheet, $row, $data, $statsTable->getDataFormats());
         $row++;
     }
     // AGGREGATIONS //
     if ($this->enableAggregation) {
         $this->applyValues($sheet, $row, $statsTable->getAggregations(), $statsTable->getAggregationsFormats(), $this->getAggregationsStyleArray());
     }
     // FINAL FORMATTING //
     for ($col = 0; $col < $width; $col++) {
         $sheet->getColumnDimension(\PHPExcel_Cell::stringFromColumnIndex($col))->setAutoSize(true);
     }
     $xlsDumper = new \PHPExcel_Writer_Excel2007($excel);
     $pFilename = @tempnam(\PHPExcel_Shared_File::sys_get_temp_dir(), 'phpxltmp');
     $xlsDumper->save($pFilename);
     $contents = file_get_contents($pFilename);
     @unlink($pFilename);
     unset($excel);
     unset($xlsDumper);
     return $contents;
 }

 /**
  * Create a new PHPExcel_Shared_XMLWriter instance
  *
  * @param int		$pTemporaryStorage			Temporary storage location
  * @param string	$pTemporaryStorageFolder	Temporary storage folder
  */
 public function __construct($pTemporaryStorage = self::STORAGE_MEMORY, $pTemporaryStorageFolder = NULL)
 {
     // Open temporary storage
     if ($pTemporaryStorage == self::STORAGE_MEMORY) {
         $this->openMemory();
     } else {
         // Create temporary filename
         if ($pTemporaryStorageFolder === NULL) {
             $pTemporaryStorageFolder = PHPExcel_Shared_File::sys_get_temp_dir();
         }
         $this->_tempFileName = @tempnam($pTemporaryStorageFolder, 'xml');
         // Open storage
         if ($this->openUri($this->_tempFileName) === false) {
             // Fallback to memory...
             $this->openMemory();
         }
     }
     // Set default values
     if (DEBUGMODE_ENABLED) {
         $this->setIndent(true);
     }
 }

 /**
  *  Create a new PHPExcel_Writer_PDF
  *
  *  @param     PHPExcel    $phpExcel    PHPExcel object
  */
 public function __construct(PHPExcel $phpExcel)
 {
     parent::__construct($phpExcel);
     $this->setUseInlineCss(TRUE);
     $this->_tempDir = PHPExcel_Shared_File::sys_get_temp_dir();
 }

 public function __construct(PHPExcel_Worksheet $parent)
 {
     parent::__construct($parent);
     if (is_null($this->_fileHandle)) {
         $baseUnique = $this->_getUniqueID();
         $this->_fileName = PHPExcel_Shared_File::sys_get_temp_dir() . '/PHPExcel.' . $baseUnique . '.cache';
         $this->_fileHandle = fopen($this->_fileName, 'a+');
     }
 }

 /**
  * Generate chart tag in cell
  *
  * @param	PHPExcel_Worksheet	$pSheet			PHPExcel_Worksheet
  * @param	string				$coordinates	Cell coordinates
  * @return	string
  * @throws	PHPExcel_Writer_Exception
  */
 private function _writeChartInCell(PHPExcel_Worksheet $pSheet, $coordinates)
 {
     // Construct HTML
     $html = '';
     // Write charts
     foreach ($pSheet->getChartCollection() as $chart) {
         if ($chart instanceof PHPExcel_Chart) {
             $chartCoordinates = $chart->getTopLeftPosition();
             if ($chartCoordinates['cell'] == $coordinates) {
                 $chartFileName = PHPExcel_Shared_File::sys_get_temp_dir() . '/' . uniqid() . '.png';
                 if (!$chart->render($chartFileName)) {
                     return;
                 }
                 $html .= PHP_EOL;
                 $imageDetails = getimagesize($chartFileName);
                 if ($fp = fopen($chartFileName, "rb", 0)) {
                     $picture = fread($fp, filesize($chartFileName));
                     fclose($fp);
                     // base64 encode the binary data, then break it
                     // into chunks according to RFC 2045 semantics
                     $base64 = chunk_split(base64_encode($picture));
                     $imageData = 'data:' . $imageDetails['mime'] . ';base64,' . $base64;
                     $html .= '<div style="position: relative;">';
                     $html .= '<img style="position: absolute; z-index: 1; left: ' . $chartCoordinates['xOffset'] . 'px; top: ' . $chartCoordinates['yOffset'] . 'px; width: ' . $imageDetails[0] . 'px; height: ' . $imageDetails[1] . 'px;" src="' . $imageData . '" border="0" />' . PHP_EOL;
                     $html .= '</div>';
                     unlink($chartFileName);
                 }
             }
         }
     }
     // Return
     return $html;
 }

 /**
  * 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));
//.........这里部分代码省略.........

 /**
  * Create a new PHPExcel_Writer_Excel5
  *
  * @param	PHPExcel	$phpExcel	PHPExcel object
  */
 public function __construct(PHPExcel $phpExcel)
 {
     $this->_preCalculateFormulas = true;
     $this->_phpExcel = $phpExcel;
     $this->_BIFF_version = 0x600;
     $this->_tempDir = PHPExcel_Shared_File::sys_get_temp_dir();
     $this->_str_total = 0;
     $this->_str_unique = 0;
     $this->_str_table = array();
     $this->_parser = new PHPExcel_Writer_Excel5_Parser($this->_BIFF_version);
 }

	/**
	* Loads the content of a LPC_Excel_base descendant.
	* This method fills in three properties: fileName, mimeType and content.
	*
	* @return void, but exceptions are thrown on errors
	*/
	public function fromExcel($ExcelObject, $fileName)
	{
		if (!$ExcelObject instanceof LPC_Excel_base)
			throw new RuntimeException("Expecting a LPC_Excel_base descendant!");

		$pFilename = @tempnam(PHPExcel_Shared_File::sys_get_temp_dir(), 'phpxltmp');
		if ($pFilename=='')
			throw new RuntimeException("Failed creating temporary file");
		$this->fileName=$fileName;
		$ExcelObject->export($fileName, $pFilename);
		$this->content=file_get_contents($pFilename);
		unlink($pFilename);

		// Really?
		$this->mimeType='application/ms-excel';
	}

 /**
  * Save PHPExcel to file
  *
  * @param  string  $pFilename
  * @throws PHPExcel_Writer_Exception
  */
 public function save($pFilename = null)
 {
     if (!$this->spreadSheet) {
         throw new PHPExcel_Writer_Exception('PHPExcel object unassigned.');
     }
     // 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;
         }
     }
     $objZip = $this->createZip($pFilename);
     $objZip->addFromString('META-INF/manifest.xml', $this->getWriterPart('meta_inf')->writeManifest());
     $objZip->addFromString('Thumbnails/thumbnail.png', $this->getWriterPart('thumbnails')->writeThumbnail());
     $objZip->addFromString('content.xml', $this->getWriterPart('content')->write());
     $objZip->addFromString('meta.xml', $this->getWriterPart('meta')->write());
     $objZip->addFromString('mimetype', $this->getWriterPart('mimetype')->write());
     $objZip->addFromString('settings.xml', $this->getWriterPart('settings')->write());
     $objZip->addFromString('styles.xml', $this->getWriterPart('styles')->write());
     // Close file
     if ($objZip->close() === false) {
         throw new PHPExcel_Writer_Exception("Could not close zip file {$pFilename}.");
     }
     // If a temporary file was used, copy it to the correct file stream
     if ($originalFilename != $pFilename) {
         if (copy($pFilename, $originalFilename) === false) {
             throw new PHPExcel_Writer_Exception("Could not copy temporary zip file {$pFilename} to {$originalFilename}.");
         }
         @unlink($pFilename);
     }
 }