init
This commit is contained in:
413
include/PHPExcel/PHPExcel.php
Executable file
413
include/PHPExcel/PHPExcel.php
Executable file
@@ -0,0 +1,413 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_DocumentProperties */
|
||||
require_once 'PHPExcel/DocumentProperties.php';
|
||||
|
||||
/** PHPExcel_DocumentSecurity */
|
||||
require_once 'PHPExcel/DocumentSecurity.php';
|
||||
|
||||
/** PHPExcel_Worksheet */
|
||||
require_once 'PHPExcel/Worksheet.php';
|
||||
|
||||
/** PHPExcel_Shared_ZipStreamWrapper */
|
||||
require_once 'PHPExcel/Shared/ZipStreamWrapper.php';
|
||||
|
||||
/** PHPExcel_NamedRange */
|
||||
require_once 'PHPExcel/NamedRange.php';
|
||||
|
||||
/** PHPExcel_WorksheetIterator */
|
||||
require_once 'PHPExcel/WorksheetIterator.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel
|
||||
{
|
||||
/**
|
||||
* Document properties
|
||||
*
|
||||
* @var PHPExcel_DocumentProperties
|
||||
*/
|
||||
private $_properties;
|
||||
|
||||
/**
|
||||
* Document security
|
||||
*
|
||||
* @var PHPExcel_DocumentSecurity
|
||||
*/
|
||||
private $_security;
|
||||
|
||||
/**
|
||||
* Collection of Worksheet objects
|
||||
*
|
||||
* @var PHPExcel_Worksheet[]
|
||||
*/
|
||||
private $_workSheetCollection = array();
|
||||
|
||||
/**
|
||||
* Active sheet index
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_activeSheetIndex = 0;
|
||||
|
||||
/**
|
||||
* Named ranges
|
||||
*
|
||||
* @var PHPExcel_NamedRange[]
|
||||
*/
|
||||
private $_namedRanges = array();
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel with one Worksheet
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
// 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();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get properties
|
||||
*
|
||||
* @return PHPExcel_DocumentProperties
|
||||
*/
|
||||
public function getProperties()
|
||||
{
|
||||
return $this->_properties;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set properties
|
||||
*
|
||||
* @param PHPExcel_DocumentProperties $pValue
|
||||
*/
|
||||
public function setProperties(PHPExcel_DocumentProperties $pValue)
|
||||
{
|
||||
$this->_properties = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get security
|
||||
*
|
||||
* @return PHPExcel_DocumentSecurity
|
||||
*/
|
||||
public function getSecurity()
|
||||
{
|
||||
return $this->_security;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set security
|
||||
*
|
||||
* @param PHPExcel_DocumentSecurity $pValue
|
||||
*/
|
||||
public function setSecurity(PHPExcel_DocumentSecurity $pValue)
|
||||
{
|
||||
$this->_security = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get active sheet
|
||||
*
|
||||
* @return PHPExcel_Worksheet
|
||||
*/
|
||||
public function getActiveSheet()
|
||||
{
|
||||
return $this->_workSheetCollection[$this->_activeSheetIndex];
|
||||
}
|
||||
|
||||
/**
|
||||
* Create sheet and add it to this workbook
|
||||
*
|
||||
* @return PHPExcel_Worksheet
|
||||
*/
|
||||
public function createSheet()
|
||||
{
|
||||
$newSheet = new PHPExcel_Worksheet($this);
|
||||
|
||||
$this->addSheet($newSheet);
|
||||
|
||||
return $newSheet;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add sheet
|
||||
*
|
||||
* @param PHPExcel_Worksheet $pSheet
|
||||
* @throws Exception
|
||||
*/
|
||||
public function addSheet(PHPExcel_Worksheet $pSheet = null)
|
||||
{
|
||||
$this->_workSheetCollection[] = $pSheet;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove sheet by index
|
||||
*
|
||||
* @param int $pIndex Active sheet index
|
||||
* @throws Exception
|
||||
*/
|
||||
public function removeSheetByIndex($pIndex = 0)
|
||||
{
|
||||
if ($pIndex > count($this->_workSheetCollection) - 1) {
|
||||
throw new Exception("Sheet index is out of bounds.");
|
||||
} else {
|
||||
array_splice($this->_workSheetCollection, $pIndex, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get sheet by index
|
||||
*
|
||||
* @param int $pIndex Sheet index
|
||||
* @return PHPExcel_Worksheet
|
||||
* @throws Exception
|
||||
*/
|
||||
public function getSheet($pIndex = 0)
|
||||
{
|
||||
if ($pIndex > count($this->_workSheetCollection) - 1) {
|
||||
throw new Exception("Sheet index is out of bounds.");
|
||||
} else {
|
||||
return $this->_workSheetCollection[$pIndex];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all sheets
|
||||
*
|
||||
* @return PHPExcel_Worksheet[]
|
||||
*/
|
||||
public function getAllSheets()
|
||||
{
|
||||
return $this->_workSheetCollection;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get sheet by name
|
||||
*
|
||||
* @param string $pName Sheet name
|
||||
* @return PHPExcel_Worksheet
|
||||
* @throws Exception
|
||||
*/
|
||||
public function getSheetByName($pName = '')
|
||||
{
|
||||
$worksheetCount = count($this->_workSheetCollection);
|
||||
for ($i = 0; $i < $worksheetCount; ++$i) {
|
||||
if ($this->_workSheetCollection[$i]->getTitle() == $pName) {
|
||||
return $this->_workSheetCollection[$i];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get index for sheet
|
||||
*
|
||||
* @param PHPExcel_Worksheet $pSheet
|
||||
* @return Sheet index
|
||||
* @throws Exception
|
||||
*/
|
||||
public function getIndex(PHPExcel_Worksheet $pSheet)
|
||||
{
|
||||
foreach ($this->_workSheetCollection as $key => $value) {
|
||||
if ($value->getHashCode() == $pSheet->getHashCode()) {
|
||||
return $key;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get sheet count
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getSheetCount()
|
||||
{
|
||||
return count($this->_workSheetCollection);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get active sheet index
|
||||
*
|
||||
* @return int Active sheet index
|
||||
*/
|
||||
public function getActiveSheetIndex()
|
||||
{
|
||||
return $this->_activeSheetIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set active sheet index
|
||||
*
|
||||
* @param int $pIndex Active sheet index
|
||||
* @throws Exception
|
||||
*/
|
||||
public function setActiveSheetIndex($pIndex = 0)
|
||||
{
|
||||
if ($pIndex > count($this->_workSheetCollection) - 1) {
|
||||
throw new Exception("Active sheet index is out of bounds.");
|
||||
} else {
|
||||
$this->_activeSheetIndex = $pIndex;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get sheet names
|
||||
*
|
||||
* @return string[]
|
||||
*/
|
||||
public function getSheetNames()
|
||||
{
|
||||
$returnValue = array();
|
||||
$worksheetCount = $this->getSheetCount();
|
||||
for ($i = 0; $i < $worksheetCount; ++$i) {
|
||||
array_push($returnValue, $this->getSheet($i)->getTitle());
|
||||
}
|
||||
|
||||
return $returnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add external sheet
|
||||
*
|
||||
* @param PHPExcel_Worksheet $pSheet External sheet to add
|
||||
* @throws Exception
|
||||
*/
|
||||
public function addExternalSheet(PHPExcel_Worksheet $pSheet) {
|
||||
if (!is_null($this->getSheetByName($pSheet->getTitle()))) {
|
||||
throw new Exception("Workbook already contains a worksheet named '{$pSheet->getTitle()}'. Rename the external sheet first.");
|
||||
}
|
||||
|
||||
$pSheet->rebindParent($this);
|
||||
$this->addSheet($pSheet);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get named ranges
|
||||
*
|
||||
* @return PHPExcel_NamedRange[]
|
||||
*/
|
||||
public function getNamedRanges() {
|
||||
return $this->_namedRanges;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add named range
|
||||
*
|
||||
* @param PHPExcel_NamedRange $namedRange
|
||||
*/
|
||||
public function addNamedRange(PHPExcel_NamedRange $namedRange) {
|
||||
$this->_namedRanges[$namedRange->getName()] = $namedRange;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get named range
|
||||
*
|
||||
* @param string $namedRange
|
||||
*/
|
||||
public function getNamedRange($namedRange) {
|
||||
if ($namedRange != '' && !is_null($namedRange) && @isset($this->_namedRanges[$namedRange])) {
|
||||
return $this->_namedRanges[$namedRange];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove named range
|
||||
*
|
||||
* @param string $namedRange
|
||||
*/
|
||||
public function removeNamedRange($namedRange) {
|
||||
if ($namedRange != '' && !is_null($namedRange) && @isset($this->_namedRanges[$namedRange])) {
|
||||
unset($this->_namedRanges[$namedRange]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get worksheet iterator
|
||||
*
|
||||
* @return PHPExcel_WorksheetIterator
|
||||
*/
|
||||
public function getWorksheetIterator() {
|
||||
return new PHPExcel_WorksheetIterator($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy workbook (!= clone!)
|
||||
*
|
||||
* @return PHPExcel
|
||||
*/
|
||||
public function copy() {
|
||||
$copied = clone $this;
|
||||
|
||||
$worksheetCount = count($this->_workSheetCollection);
|
||||
for ($i = 0; $i < $worksheetCount; ++$i) {
|
||||
$this->_workSheetCollection[$i] = $this->_workSheetCollection[$i]->copy();
|
||||
$this->_workSheetCollection[$i]->rebindParent($this);
|
||||
}
|
||||
|
||||
return $copied;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
903
include/PHPExcel/PHPExcel/Calculation.php
Executable file
903
include/PHPExcel/PHPExcel/Calculation.php
Executable file
@@ -0,0 +1,903 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/** PHPExcel_Worksheet */
|
||||
require_once 'PHPExcel/Worksheet.php';
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_Cell_DataType */
|
||||
require_once 'PHPExcel/Cell/DataType.php';
|
||||
|
||||
/** PHPExcel_RichText */
|
||||
require_once 'PHPExcel/RichText.php';
|
||||
|
||||
/** PHPExcel_NamedRange */
|
||||
require_once 'PHPExcel/NamedRange.php';
|
||||
|
||||
/** PHPExcel_Calculation_FormulaParser */
|
||||
require_once 'PHPExcel/Calculation/FormulaParser.php';
|
||||
|
||||
/** PHPExcel_Calculation_FormulaToken */
|
||||
require_once 'PHPExcel/Calculation/FormulaToken.php';
|
||||
|
||||
/** PHPExcel_Calculation_Functions */
|
||||
require_once 'PHPExcel/Calculation/Functions.php';
|
||||
|
||||
/** PHPExcel_Calculation_Function */
|
||||
require_once 'PHPExcel/Calculation/Function.php';
|
||||
|
||||
/** PHPExcel_Calculation_ExceptionHandler */
|
||||
require_once 'PHPExcel/Calculation/ExceptionHandler.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_Calculation (Singleton)
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Calculation {
|
||||
|
||||
/** constants */
|
||||
const RETURN_ARRAY_AS_VALUE = 'value';
|
||||
const RETURN_ARRAY_AS_ARRAY = 'array';
|
||||
|
||||
private static $returnArrayAsType = self::RETURN_ARRAY_AS_ARRAY;
|
||||
|
||||
/**
|
||||
* Function mappings (from Excel to PHPExcel)
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_functionMappings = null;
|
||||
|
||||
/**
|
||||
* Calculation cache
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_calculationCache = array ( );
|
||||
|
||||
/**
|
||||
* Calculation cache enabled
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_calculationCacheEnabled = true;
|
||||
|
||||
/**
|
||||
* Calculation cache expiration time
|
||||
*
|
||||
* @var float
|
||||
*/
|
||||
private $_calculationCacheExpirationTime = 0.01;
|
||||
|
||||
/**
|
||||
* Instance of this class
|
||||
*
|
||||
* @var PHPExcel_Calculation
|
||||
*/
|
||||
private static $_instance;
|
||||
|
||||
/**
|
||||
* Get an instance of this class
|
||||
*
|
||||
* @return PHPExcel_Calculation
|
||||
*/
|
||||
public static function getInstance() {
|
||||
if (! isset ( self::$_instance ) || is_null ( self::$_instance )) {
|
||||
self::$_instance = new PHPExcel_Calculation ( );
|
||||
}
|
||||
|
||||
return self::$_instance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the Array Return Type (Array or Value of first element in the array)
|
||||
*
|
||||
* @param string $returnType Array return type
|
||||
* @return boolean Success or failure
|
||||
*/
|
||||
public static function setArrayReturnType($returnType) {
|
||||
if (($returnType == self::RETURN_ARRAY_AS_VALUE) ||
|
||||
($returnType == self::RETURN_ARRAY_AS_ARRAY)) {
|
||||
self::$returnArrayAsType = $returnType;
|
||||
return True;
|
||||
}
|
||||
return False;
|
||||
} // function setExcelCalendar()
|
||||
|
||||
|
||||
/**
|
||||
* Return the Array Return Type (Array or Value of first element in the array)
|
||||
*
|
||||
* @return string $returnType Array return type
|
||||
*/
|
||||
public static function getArrayReturnType() {
|
||||
return self::$returnArrayAsType;
|
||||
} // function getExcelCalendar()
|
||||
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Calculation
|
||||
*/
|
||||
protected function __construct() {
|
||||
// Assign function mappings
|
||||
if (is_null($this->_functionMappings)) {
|
||||
$this->_functionMappings = array(
|
||||
'ABS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ABS', 'abs'),
|
||||
'ACCRINT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'ACCRINT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ACCRINTM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'ACCRINTM', 'PHPExcel_Calculation_Functions::ACCRINTM'),
|
||||
'ACOS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ACOS', 'acos'),
|
||||
'ACOSH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ACOSH', 'acosh'),
|
||||
'ADDRESS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'ADDRESS', 'PHPExcel_Calculation_Functions::CELL_ADDRESS'),
|
||||
'AMORDEGRC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'AMORDEGRC', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'AMORLINC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'AMORLINC', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'AND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'AND', 'PHPExcel_Calculation_Functions::LOGICAL_AND'),
|
||||
'AREAS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'AREAS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ASC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'ASC', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ASIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ASIN', 'asin'),
|
||||
'ASINH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ASINH', 'asinh'),
|
||||
'ATAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ATAN', 'atan'),
|
||||
'ATAN2' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ATAN2', 'PHPExcel_Calculation_Functions::REVERSE_ATAN2'),
|
||||
'ATANH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ATANH', 'atanh'),
|
||||
'AVEDEV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'AVEDEV', 'PHPExcel_Calculation_Functions::AVEDEV'),
|
||||
'AVERAGE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'AVERAGE', 'PHPExcel_Calculation_Functions::AVERAGE'),
|
||||
'AVERAGEA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'AVERAGEA', 'PHPExcel_Calculation_Functions::AVERAGEA'),
|
||||
'AVERAGEIF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'AVERAGEIF', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'AVERAGEIFS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'AVERAGEIFS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'BAHTTEXT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'BAHTTEXT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'BESSELI' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BESSELI', 'PHPExcel_Calculation_Functions::BESSELI'),
|
||||
'BESSELJ' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BESSELJ', 'PHPExcel_Calculation_Functions::BESSELJ'),
|
||||
'BESSELK' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BESSELK', 'PHPExcel_Calculation_Functions::BESSELK'),
|
||||
'BESSELY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BESSELY', 'PHPExcel_Calculation_Functions::BESSELY'),
|
||||
'BETADIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'BETADIST', 'PHPExcel_Calculation_Functions::BETADIST'),
|
||||
'BETAINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'BETAINV', 'PHPExcel_Calculation_Functions::BETAINV'),
|
||||
'BIN2DEC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BIN2DEC', 'PHPExcel_Calculation_Functions::BINTODEC'),
|
||||
'BIN2HEX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BIN2HEX', 'PHPExcel_Calculation_Functions::BINTOHEX'),
|
||||
'BIN2OCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'BIN2OCT', 'PHPExcel_Calculation_Functions::BINTOOCT'),
|
||||
'BINOMDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'BINOMDIST', 'PHPExcel_Calculation_Functions::BINOMDIST'),
|
||||
'CEILING' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'CEILING', 'PHPExcel_Calculation_Functions::CEILING'),
|
||||
'CELL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'CELL', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CHAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'CHAR', 'chr'),
|
||||
'CHIDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'CHIDIST', 'PHPExcel_Calculation_Functions::CHIDIST'),
|
||||
'CHIINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'CHIINV', 'PHPExcel_Calculation_Functions::CHIINV'),
|
||||
'CHITEST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'CHITEST', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CHOOSE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'CHOOSE', 'PHPExcel_Calculation_Functions::CHOOSE'),
|
||||
'CLEAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'CLEAN', 'PHPExcel_Calculation_Functions::TRIMNONPRINTABLE'),
|
||||
'CODE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'CODE', 'PHPExcel_Calculation_Functions::ASCIICODE'),
|
||||
'COLUMN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'COLUMN', 'PHPExcel_Calculation_Functions::COLUMN'),
|
||||
'COLUMNS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'COLUMNS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COMBIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'COMBIN', 'PHPExcel_Calculation_Functions::COMBIN'),
|
||||
'COMPLEX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'COMPLEX', 'PHPExcel_Calculation_Functions::COMPLEX'),
|
||||
'CONCATENATE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'CONCATENATE', 'PHPExcel_Calculation_Functions::CONCATENATE'),
|
||||
'CONFIDENCE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'CONFIDENCE', 'PHPExcel_Calculation_Functions::CONFIDENCE'),
|
||||
'CONVERT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'CONVERT', 'PHPExcel_Calculation_Functions::CONVERTUOM'),
|
||||
'CORREL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'CORREL', 'PHPExcel_Calculation_Functions::CORREL'),
|
||||
'COS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'COS', 'cos'),
|
||||
'COSH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'COSH', 'cosh'),
|
||||
'COUNT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'COUNT', 'PHPExcel_Calculation_Functions::COUNT'),
|
||||
'COUNTA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'COUNTA', 'PHPExcel_Calculation_Functions::COUNTA'),
|
||||
'COUNTBLANK' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'COUNTBLANK', 'PHPExcel_Calculation_Functions::COUNTBLANK'),
|
||||
'COUNTIF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'COUNTIF', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COUNTIFS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'COUNTIFS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COUPDAYBS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'COUPDAYBS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COUPDAYSNC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'COUPDAYSNC', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COUPNCD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'COUPNCD', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COUPNUM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'COUPNUM', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COUPPCD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'COUPPCD', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'COVAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'COVAR', 'PHPExcel_Calculation_Functions::COVAR'),
|
||||
'CRITBINOM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'CRITBINOM', 'PHPExcel_Calculation_Functions::CRITBINOM'),
|
||||
'CUBEKPIMEMBER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBEKPIMEMBER', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUBEMEMBER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBEMEMBER', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUBEMEMBERPROPERTY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBEMEMBERPROPERTY', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUBERANKEDMEMBER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBERANKEDMEMBER', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUBESET' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBESET', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUBESETCOUNT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBESETCOUNT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUBEVALUE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_CUBE, 'CUBEVALUE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'CUMIPMT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'CUMIPMT', 'PHPExcel_Calculation_Functions::CUMIPMT'),
|
||||
'CUMPRINC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'CUMPRINC', 'PHPExcel_Calculation_Functions::CUMPRINC'),
|
||||
'DATE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'DATE', 'PHPExcel_Calculation_Functions::DATE'),
|
||||
'DATEDIF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'DATEDIF', 'PHPExcel_Calculation_Functions::DATEDIF'),
|
||||
'DATEVALUE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'DATEVALUE', 'PHPExcel_Calculation_Functions::DATEVALUE'),
|
||||
'DAVERAGE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DAVERAGE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DAY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'DAY', 'PHPExcel_Calculation_Functions::DAYOFMONTH'),
|
||||
'DAYS360' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'DAYS360', 'PHPExcel_Calculation_Functions::DAYS360'),
|
||||
'DB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'DB', 'PHPExcel_Calculation_Functions::DB'),
|
||||
'DCOUNT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DCOUNT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DCOUNTA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DCOUNTA', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DDB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'DDB', 'PHPExcel_Calculation_Functions::DDB'),
|
||||
'DEC2BIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'DEC2BIN', 'PHPExcel_Calculation_Functions::DECTOBIN'),
|
||||
'DEC2HEX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'DEC2HEX', 'PHPExcel_Calculation_Functions::DECTOHEX'),
|
||||
'DEC2OCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'DEC2OCT', 'PHPExcel_Calculation_Functions::DECTOOCT'),
|
||||
'DEGREES' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'DEGREES', 'rad2deg'),
|
||||
'DELTA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'DELTA', 'PHPExcel_Calculation_Functions::DELTA'),
|
||||
'DEVSQ' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'DEVSQ', 'PHPExcel_Calculation_Functions::DEVSQ'),
|
||||
'DGET' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DGET', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DISC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'DISC', 'PHPExcel_Calculation_Functions::DISC'),
|
||||
'DMAX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DMAX', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DMIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DMIN', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DOLLAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'DOLLAR', 'PHPExcel_Calculation_Functions::DOLLAR'),
|
||||
'DOLLARDE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'DOLLARDE', 'PHPExcel_Calculation_Functions::DOLLARDE'),
|
||||
'DOLLARFR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'DOLLARFR', 'PHPExcel_Calculation_Functions::DOLLARFR'),
|
||||
'DPRODUCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DPRODUCT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DSTDEV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DSTDEV', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DSTDEVP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DSTDEVP', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DSUM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DSUM', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DURATION' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'DURATION', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DVAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DVAR', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'DVARP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATABASE, 'DVARP', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'EDATE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'EDATE', 'PHPExcel_Calculation_Functions::EDATE'),
|
||||
'EFFECT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'EFFECT', 'PHPExcel_Calculation_Functions::EFFECT'),
|
||||
'EOMONTH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'EOMONTH', 'PHPExcel_Calculation_Functions::EOMONTH'),
|
||||
'ERF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'ERF', 'PHPExcel_Calculation_Functions::ERF'),
|
||||
'ERFC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'ERFC', 'PHPExcel_Calculation_Functions::ERFC'),
|
||||
'ERROR.TYPE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ERROR.TYPE', 'PHPExcel_Calculation_Functions::ERROR_TYPE'),
|
||||
'EVEN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'EVEN', 'PHPExcel_Calculation_Functions::EVEN'),
|
||||
'EXACT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'EXACT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'EXP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'EXP', 'exp'),
|
||||
'EXPONDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'EXPONDIST', 'PHPExcel_Calculation_Functions::EXPONDIST'),
|
||||
'FACT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'FACT', 'PHPExcel_Calculation_Functions::FACT'),
|
||||
'FACTDOUBLE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'FACTDOUBLE', 'PHPExcel_Calculation_Functions::FACTDOUBLE'),
|
||||
'FALSE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'FALSE', 'PHPExcel_Calculation_Functions::LOGICAL_FALSE'),
|
||||
'FDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FDIST', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'FIND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'FIND', 'PHPExcel_Calculation_Functions::SEARCHSENSITIVE'),
|
||||
'FINDB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'FINDB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'FINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FINV', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'FISHER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FISHER', 'PHPExcel_Calculation_Functions::FISHER'),
|
||||
'FISHERINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FISHERINV', 'PHPExcel_Calculation_Functions::FISHERINV'),
|
||||
'FIXED' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'FIXED', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'FLOOR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'FLOOR', 'PHPExcel_Calculation_Functions::FLOOR'),
|
||||
'FORECAST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FORECAST', 'PHPExcel_Calculation_Functions::FORECAST'),
|
||||
'FREQUENCY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FREQUENCY', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'FTEST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'FTEST', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'FV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'FV', 'PHPExcel_Calculation_Functions::FV'),
|
||||
'FVSCHEDULE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'FVSCHEDULE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'GAMMADIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'GAMMADIST', 'PHPExcel_Calculation_Functions::GAMMADIST'),
|
||||
'GAMMAINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'GAMMAINV', 'PHPExcel_Calculation_Functions::GAMMAINV'),
|
||||
'GAMMALN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'GAMMALN', 'PHPExcel_Calculation_Functions::GAMMALN'),
|
||||
'GCD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'GCD', 'PHPExcel_Calculation_Functions::GCD'),
|
||||
'GEOMEAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'GEOMEAN', 'PHPExcel_Calculation_Functions::GEOMEAN'),
|
||||
'GESTEP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'GESTEP', 'PHPExcel_Calculation_Functions::GESTEP'),
|
||||
'GETPIVOTDATA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'GETPIVOTDATA', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'GROWTH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'GROWTH', 'PHPExcel_Calculation_Functions::GROWTH'),
|
||||
'HARMEAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'HARMEAN', 'PHPExcel_Calculation_Functions::HARMEAN'),
|
||||
'HEX2BIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'HEX2BIN', 'PHPExcel_Calculation_Functions::HEXTOBIN'),
|
||||
'HEX2DEC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'HEX2DEC', 'PHPExcel_Calculation_Functions::HEXTODEC'),
|
||||
'HEX2OCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'HEX2OCT', 'PHPExcel_Calculation_Functions::HEXTOOCT'),
|
||||
'HLOOKUP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'HLOOKUP', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'HOUR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'HOUR', 'PHPExcel_Calculation_Functions::HOUROFDAY'),
|
||||
'HYPERLINK' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'HYPERLINK', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'HYPGEOMDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'HYPGEOMDIST', 'PHPExcel_Calculation_Functions::HYPGEOMDIST'),
|
||||
'IF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'IF', 'PHPExcel_Calculation_Functions::STATEMENT_IF'),
|
||||
'IFERROR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'IFERROR', 'PHPExcel_Calculation_Functions::STATEMENT_IFERROR'),
|
||||
'IMABS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMABS', 'PHPExcel_Calculation_Functions::IMABS'),
|
||||
'IMAGINARY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMAGINARY', 'PHPExcel_Calculation_Functions::IMAGINARY'),
|
||||
'IMARGUMENT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMARGUMENT', 'PHPExcel_Calculation_Functions::IMARGUMENT'),
|
||||
'IMCONJUGATE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMCONJUGATE', 'PHPExcel_Calculation_Functions::IMCONJUGATE'),
|
||||
'IMCOS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMCOS', 'PHPExcel_Calculation_Functions::IMCOS'),
|
||||
'IMDIV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMDIV', 'PHPExcel_Calculation_Functions::IMDIV'),
|
||||
'IMEXP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMEXP', 'PHPExcel_Calculation_Functions::IMEXP'),
|
||||
'IMLN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMLN', 'PHPExcel_Calculation_Functions::IMLN'),
|
||||
'IMLOG10' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMLOG10', 'PHPExcel_Calculation_Functions::IMLOG10'),
|
||||
'IMLOG2' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMLOG2', 'PHPExcel_Calculation_Functions::IMLOG2'),
|
||||
'IMPOWER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMPOWER', 'PHPExcel_Calculation_Functions::IMPOWER'),
|
||||
'IMPRODUCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMPRODUCT', 'PHPExcel_Calculation_Functions::IMPRODUCT'),
|
||||
'IMREAL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMREAL', 'PHPExcel_Calculation_Functions::IMREAL'),
|
||||
'IMSIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMSIN', 'PHPExcel_Calculation_Functions::IMSIN'),
|
||||
'IMSQRT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMSQRT', 'PHPExcel_Calculation_Functions::IMSQRT'),
|
||||
'IMSUB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMSUB', 'PHPExcel_Calculation_Functions::IMSUB'),
|
||||
'IMSUM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'IMSUM', 'PHPExcel_Calculation_Functions::IMSUM'),
|
||||
'INDEX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'INDEX', 'PHPExcel_Calculation_Functions::INDEX'),
|
||||
'INDIRECT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'INDIRECT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'INFO' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'INFO', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'INT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'INT', 'intval'),
|
||||
'INTERCEPT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'INTERCEPT', 'PHPExcel_Calculation_Functions::INTERCEPT'),
|
||||
'INTRATE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'INTRATE', 'PHPExcel_Calculation_Functions::INTRATE'),
|
||||
'IPMT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'IPMT', 'PHPExcel_Calculation_Functions::IPMT'),
|
||||
'IRR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'IRR', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ISBLANK' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISBLANK', 'PHPExcel_Calculation_Functions::IS_BLANK'),
|
||||
'ISERR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISERR', 'PHPExcel_Calculation_Functions::IS_ERR'),
|
||||
'ISERROR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISERROR', 'PHPExcel_Calculation_Functions::IS_ERROR'),
|
||||
'ISEVEN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISEVEN', 'PHPExcel_Calculation_Functions::IS_EVEN'),
|
||||
'ISLOGICAL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISLOGICAL', 'PHPExcel_Calculation_Functions::IS_LOGICAL'),
|
||||
'ISNA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISNA', 'PHPExcel_Calculation_Functions::IS_NA'),
|
||||
'ISNONTEXT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISNONTEXT', '!PHPExcel_Calculation_Functions::IS_TEXT'),
|
||||
'ISNUMBER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISNUMBER', 'PHPExcel_Calculation_Functions::IS_NUMBER'),
|
||||
'ISODD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISODD', '!PHPExcel_Calculation_Functions::IS_EVEN'),
|
||||
'ISPMT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISPMT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ISREF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISREF', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ISTEXT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'ISTEXT', 'PHPExcel_Calculation_Functions::IS_TEXT'),
|
||||
'JIS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'JIS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'KURT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'KURT', 'PHPExcel_Calculation_Functions::KURT'),
|
||||
'LARGE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'LARGE', 'PHPExcel_Calculation_Functions::LARGE'),
|
||||
'LCM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'LCM', 'PHPExcel_Calculation_Functions::LCM'),
|
||||
'LEFT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'LEFT', 'PHPExcel_Calculation_Functions::LEFT'),
|
||||
'LEFTB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'LEFTB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'LEN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'LEN', 'strlen'),
|
||||
'LENB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'LENB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'LINEST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'LINEST', 'PHPExcel_Calculation_Functions::LINEST'),
|
||||
'LN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'LN', 'log'),
|
||||
'LOG' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'LOG', 'log'),
|
||||
'LOG10' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'LOG10', 'log10'),
|
||||
'LOGEST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'LOGEST', 'PHPExcel_Calculation_Functions::LOGEST'),
|
||||
'LOGINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'LOGINV', 'PHPExcel_Calculation_Functions::LOGINV'),
|
||||
'LOGNORMDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'LOGNORMDIST', 'PHPExcel_Calculation_Functions::LOGNORMDIST'),
|
||||
'LOOKUP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'LOOKUP', 'PHPExcel_Calculation_Functions::LOOKUP'),
|
||||
'LOWER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'LOWER', 'strtolower'),
|
||||
'MATCH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'MATCH', 'PHPExcel_Calculation_Functions::MATCH'),
|
||||
'MAX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'MAX', 'PHPExcel_Calculation_Functions::MAX'),
|
||||
'MAXA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'MAXA', 'PHPExcel_Calculation_Functions::MAXA'),
|
||||
'MDETERM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'MDETERM', 'PHPExcel_Calculation_Functions::MDETERM'),
|
||||
'MDURATION' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'MDURATION', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'MEDIAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'MEDIAN', 'PHPExcel_Calculation_Functions::MEDIAN'),
|
||||
'MID' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'MID', 'PHPExcel_Calculation_Functions::MID'),
|
||||
'MIDB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'MIDB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'MIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'MIN', 'PHPExcel_Calculation_Functions::MIN'),
|
||||
'MINA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'MINA', 'PHPExcel_Calculation_Functions::MINA'),
|
||||
'MINUTE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'MINUTE', 'PHPExcel_Calculation_Functions::MINUTEOFHOUR'),
|
||||
'MINVERSE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'MINVERSE', 'PHPExcel_Calculation_Functions::MINVERSE'),
|
||||
'MIRR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'MIRR', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'MMULT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'MMULT', 'PHPExcel_Calculation_Functions::MMULT'),
|
||||
'MOD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'MOD', 'PHPExcel_Calculation_Functions::MOD'),
|
||||
'MODE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'MODE', 'PHPExcel_Calculation_Functions::MODE'),
|
||||
'MONTH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'MONTH', 'PHPExcel_Calculation_Functions::MONTHOFYEAR'),
|
||||
'MROUND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'MROUND', 'PHPExcel_Calculation_Functions::MROUND'),
|
||||
'MULTINOMIAL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'MULTINOMIAL', 'PHPExcel_Calculation_Functions::MULTINOMIAL'),
|
||||
'N' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'N', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'NA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'NA', 'PHPExcel_Calculation_Functions::NA'),
|
||||
'NEGBINOMDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'NEGBINOMDIST', 'PHPExcel_Calculation_Functions::NEGBINOMDIST'),
|
||||
'NETWORKDAYS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'NETWORKDAYS', 'PHPExcel_Calculation_Functions::NETWORKDAYS'),
|
||||
'NOMINAL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'NOMINAL', 'PHPExcel_Calculation_Functions::NOMINAL'),
|
||||
'NORMDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'NORMDIST', 'PHPExcel_Calculation_Functions::NORMDIST'),
|
||||
'NORMINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'NORMINV', 'PHPExcel_Calculation_Functions::NORMINV'),
|
||||
'NORMSDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'NORMSDIST', 'PHPExcel_Calculation_Functions::NORMSDIST'),
|
||||
'NORMSINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'NORMSINV', 'PHPExcel_Calculation_Functions::NORMSINV'),
|
||||
'NOT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'NOT', '!'),
|
||||
'NOW' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'NOW', 'PHPExcel_Calculation_Functions::DATETIMENOW'),
|
||||
'NPER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'NPER', 'PHPExcel_Calculation_Functions::NPER'),
|
||||
'NPV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'NPV', 'PHPExcel_Calculation_Functions::NPV'),
|
||||
'OCT2BIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'OCT2BIN', 'PHPExcel_Calculation_Functions::OCTTOBIN'),
|
||||
'OCT2DEC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'OCT2DEC', 'PHPExcel_Calculation_Functions::OCTTODEC'),
|
||||
'OCT2HEX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_ENGINEERING, 'OCT2HEX', 'PHPExcel_Calculation_Functions::OCTTOHEX'),
|
||||
'ODD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ODD', 'PHPExcel_Calculation_Functions::ODD'),
|
||||
'ODDFPRICE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'ODDFPRICE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ODDFYIELD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'ODDFYIELD', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ODDLPRICE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'ODDLPRICE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ODDLYIELD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'ODDLYIELD', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'OFFSET' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'OFFSET', 'PHPExcel_Calculation_Functions::OFFSET'),
|
||||
'OR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'OR', 'PHPExcel_Calculation_Functions::LOGICAL_OR'),
|
||||
'PEARSON' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'PEARSON', 'PHPExcel_Calculation_Functions::CORREL'),
|
||||
'PERCENTILE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'PERCENTILE', 'PHPExcel_Calculation_Functions::PERCENTILE'),
|
||||
'PERCENTRANK' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'PERCENTRANK', 'PHPExcel_Calculation_Functions::PERCENTRANK'),
|
||||
'PERMUT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'PERMUT', 'PHPExcel_Calculation_Functions::PERMUT'),
|
||||
'PHONETIC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'PHONETIC', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'PI' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'PI', 'pi'),
|
||||
'PMT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'PMT', 'PHPExcel_Calculation_Functions::PMT'),
|
||||
'POISSON' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'POISSON', 'PHPExcel_Calculation_Functions::POISSON'),
|
||||
'POWER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'POWER', 'PHPExcel_Calculation_Functions::POWER'),
|
||||
'PPMT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'PPMT', 'PHPExcel_Calculation_Functions::PPMT'),
|
||||
'PRICE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'PRICE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'PRICEDISC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'PRICEDISC', 'PHPExcel_Calculation_Functions::PRICEDISC'),
|
||||
'PRICEMAT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'PRICEMAT', 'PHPExcel_Calculation_Functions::PRICEMAT'),
|
||||
'PROB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'PROB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'PRODUCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'PRODUCT', 'PHPExcel_Calculation_Functions::PRODUCT'),
|
||||
'PROPER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'PROPER', 'ucwords'),
|
||||
'PV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'PV', 'PHPExcel_Calculation_Functions::PV'),
|
||||
'QUARTILE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'QUARTILE', 'PHPExcel_Calculation_Functions::QUARTILE'),
|
||||
'QUOTIENT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'QUOTIENT', 'PHPExcel_Calculation_Functions::QUOTIENT'),
|
||||
'RADIANS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'RADIANS', 'deg2rad'),
|
||||
'RAND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'RAND', 'PHPExcel_Calculation_Functions::RAND'),
|
||||
'RANDBETWEEN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'RANDBETWEEN', 'PHPExcel_Calculation_Functions::RAND'),
|
||||
'RANK' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'RANK', 'PHPExcel_Calculation_Functions::RANK'),
|
||||
'RATE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'RATE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'RECEIVED' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'RECEIVED', 'PHPExcel_Calculation_Functions::RECEIVED'),
|
||||
'REPLACE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'REPLACE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'REPLACEB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'REPLACEB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'REPT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'REPT', 'str_repeat'),
|
||||
'RIGHT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'RIGHT', 'PHPExcel_Calculation_Functions::RIGHT'),
|
||||
'RIGHTB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'RIGHTB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'ROMAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ROMAN', 'PHPExcel_Calculation_Functions::ROMAN'),
|
||||
'ROUND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ROUND', 'round'),
|
||||
'ROUNDDOWN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ROUNDDOWN', 'PHPExcel_Calculation_Functions::ROUNDDOWN'),
|
||||
'ROUNDUP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'ROUNDUP', 'PHPExcel_Calculation_Functions::ROUNDUP'),
|
||||
'ROW' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'ROW', 'PHPExcel_Calculation_Functions::ROW'),
|
||||
'ROWS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'ROWS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'RSQ' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'RSQ', 'PHPExcel_Calculation_Functions::RSQ'),
|
||||
'RTD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'RTD', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'SEARCH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'SEARCH', 'PHPExcel_Calculation_Functions::SEARCHINSENSITIVE'),
|
||||
'SEARCHB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'SEARCHB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'SECOND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'SECOND', 'PHPExcel_Calculation_Functions::SECONDOFMINUTE'),
|
||||
'SERIESSUM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SERIESSUM', 'PHPExcel_Calculation_Functions::SERIESSUM'),
|
||||
'SIGN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SIGN', 'PHPExcel_Calculation_Functions::SIGN'),
|
||||
'SIN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SIN', 'sin'),
|
||||
'SINH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SINH', 'sinh'),
|
||||
'SKEW' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'SKEW', 'PHPExcel_Calculation_Functions::SKEW'),
|
||||
'SLN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'SLN', 'PHPExcel_Calculation_Functions::SLN'),
|
||||
'SLOPE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'SLOPE', 'PHPExcel_Calculation_Functions::SLOPE'),
|
||||
'SMALL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'SMALL', 'PHPExcel_Calculation_Functions::SMALL'),
|
||||
'SQRT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SQRT', 'sqrt'),
|
||||
'SQRTPI' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SQRTPI', 'PHPExcel_Calculation_Functions::SQRTPI'),
|
||||
'STANDARDIZE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'STANDARDIZE', 'PHPExcel_Calculation_Functions::STANDARDIZE'),
|
||||
'STDEV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'STDEV', 'PHPExcel_Calculation_Functions::STDEV'),
|
||||
'STDEVA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'STDEVA', 'PHPExcel_Calculation_Functions::STDEVA'),
|
||||
'STDEVP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'STDEVP', 'PHPExcel_Calculation_Functions::STDEVP'),
|
||||
'STDEVPA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'STDEVPA', 'PHPExcel_Calculation_Functions::STDEVPA'),
|
||||
'STEYX' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'STEYX', 'PHPExcel_Calculation_Functions::STEYX'),
|
||||
'SUBSTITUTE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'SUBSTITUTE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'SUBTOTAL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUBTOTAL', 'PHPExcel_Calculation_Functions::SUBTOTAL'),
|
||||
'SUM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUM', 'PHPExcel_Calculation_Functions::SUM'),
|
||||
'SUMIF' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMIF', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'SUMIFS' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMIFS', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'SUMPRODUCT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMPRODUCT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'SUMSQ' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMSQ', 'PHPExcel_Calculation_Functions::SUMSQ'),
|
||||
'SUMX2MY2' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMX2MY2', 'PHPExcel_Calculation_Functions::SUMX2MY2'),
|
||||
'SUMX2PY2' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMX2PY2', 'PHPExcel_Calculation_Functions::SUMX2PY2'),
|
||||
'SUMXMY2' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'SUMXMY2', 'PHPExcel_Calculation_Functions::SUMXMY2'),
|
||||
'SYD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'SYD', 'PHPExcel_Calculation_Functions::SYD'),
|
||||
'T' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'T', 'PHPExcel_Calculation_Functions::RETURNSTRING'),
|
||||
'TAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'TAN', 'tan'),
|
||||
'TANH' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'TANH', 'tanh'),
|
||||
'TBILLEQ' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'TBILLEQ', 'PHPExcel_Calculation_Functions::TBILLEQ'),
|
||||
'TBILLPRICE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'TBILLPRICE', 'PHPExcel_Calculation_Functions::TBILLPRICE'),
|
||||
'TBILLYIELD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'TBILLYIELD', 'PHPExcel_Calculation_Functions::TBILLYIELD'),
|
||||
'TDIST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'TDIST', 'PHPExcel_Calculation_Functions::TDIST'),
|
||||
'TEXT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'TEXT', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'TIME' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'TIME', 'PHPExcel_Calculation_Functions::TIME'),
|
||||
'TIMEVALUE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'TIMEVALUE', 'PHPExcel_Calculation_Functions::TIMEVALUE'),
|
||||
'TINV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'TINV', 'PHPExcel_Calculation_Functions::TINV'),
|
||||
'TODAY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'TODAY', 'PHPExcel_Calculation_Functions::DATENOW'),
|
||||
'TRANSPOSE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'TRANSPOSE', 'PHPExcel_Calculation_Functions::TRANSPOSE'),
|
||||
'TREND' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'TREND', 'PHPExcel_Calculation_Functions::TREND'),
|
||||
'TRIM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'TRIM', 'PHPExcel_Calculation_Functions::TRIMSPACES'),
|
||||
'TRIMMEAN' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'TRIMMEAN', 'PHPExcel_Calculation_Functions::TRIMMEAN'),
|
||||
'TRUE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOGICAL, 'TRUE', 'PHPExcel_Calculation_Functions::LOGICAL_TRUE'),
|
||||
'TRUNC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG, 'TRUNC', 'PHPExcel_Calculation_Functions::TRUNC'),
|
||||
'TTEST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'TTEST', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'TYPE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'TYPE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'UPPER' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'UPPER', 'strtoupper'),
|
||||
'USDOLLAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'USDOLLAR', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'VALUE' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA, 'VALUE', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'VAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'VAR', 'PHPExcel_Calculation_Functions::VARFunc'),
|
||||
'VARA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'VARA', 'PHPExcel_Calculation_Functions::VARA'),
|
||||
'VARP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'VARP', 'PHPExcel_Calculation_Functions::VARP'),
|
||||
'VARPA' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'VARPA', 'PHPExcel_Calculation_Functions::VARPA'),
|
||||
'VDB' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'VDB', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'VERSION' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_INFORMATION, 'VERSION', 'PHPExcel_Calculation_Functions::VERSION'),
|
||||
'VLOOKUP' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE, 'VLOOKUP', 'PHPExcel_Calculation_Functions::VLOOKUP'),
|
||||
'WEEKDAY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'WEEKDAY', 'PHPExcel_Calculation_Functions::DAYOFWEEK'),
|
||||
'WEEKNUM' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'WEEKNUM', 'PHPExcel_Calculation_Functions::WEEKOFYEAR'),
|
||||
'WEIBULL' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'WEIBULL', 'PHPExcel_Calculation_Functions::WEIBULL'),
|
||||
'WORKDAY' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'WORKDAY', 'PHPExcel_Calculation_Functions::WORKDAY'),
|
||||
'XIRR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'XIRR', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'XNPV' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'XNPV', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'YEAR' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'YEAR', 'PHPExcel_Calculation_Functions::YEAR'),
|
||||
'YEARFRAC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME, 'YEARFRAC', 'PHPExcel_Calculation_Functions::YEARFRAC'),
|
||||
'YIELD' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'YIELD', 'PHPExcel_Calculation_Functions::DUMMY'),
|
||||
'YIELDDISC' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'YIELDDISC', 'PHPExcel_Calculation_Functions::YIELDDISC'),
|
||||
'YIELDMAT' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_FINANCIAL, 'YIELDMAT', 'PHPExcel_Calculation_Functions::YIELDMAT'),
|
||||
'ZTEST' => new PHPExcel_Calculation_Function(PHPExcel_Calculation_Function::CATEGORY_STATISTICAL, 'ZTEST', 'PHPExcel_Calculation_Functions::DUMMY')
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Is calculation caching enabled?
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getCalculationCacheEnabled() {
|
||||
return $this->_calculationCacheEnabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enable/disable calculation cache
|
||||
*
|
||||
* @param boolean $pValue
|
||||
*/
|
||||
public function setCalculationCacheEnabled($pValue) {
|
||||
$this->_calculationCacheEnabled = $pValue;
|
||||
$this->clearCalculationCache();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear calculation cache
|
||||
*/
|
||||
public function clearCalculationCache() {
|
||||
$this->_calculationCache = array();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get calculation cache expiration time
|
||||
*
|
||||
* @return float
|
||||
*/
|
||||
public function getCalculationCacheExpirationTime() {
|
||||
return $this->_calculationCacheExpirationTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set calculation cache expiration time
|
||||
*
|
||||
* @param float $pValue
|
||||
*/
|
||||
public function setCalculationCacheExpirationTime($pValue = 0.01) {
|
||||
$this->_calculationCacheExpirationTime = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate cell value (using formula)
|
||||
*
|
||||
* @param PHPExcel_Cell $pCell Cell to calculate
|
||||
* @return mixed
|
||||
* @throws Exception
|
||||
*/
|
||||
public function calculate(PHPExcel_Cell $pCell = null) {
|
||||
// Return value
|
||||
$returnValue = '';
|
||||
|
||||
// Is the value present in calculation cache?
|
||||
if ($this->getCalculationCacheEnabled ()) {
|
||||
if (isset ( $this->_calculationCache [$pCell->getParent ()->getTitle ()] [$pCell->getCoordinate ()] )) {
|
||||
if ((time () + microtime ()) - $this->_calculationCache [$pCell->getParent ()->getTitle ()] [$pCell->getCoordinate ()] ['time'] < $this->_calculationCacheExpirationTime) {
|
||||
// Return result
|
||||
$returnValue = $this->_calculationCache [$pCell->getParent ()->getTitle ()] [$pCell->getCoordinate ()] ['data'];
|
||||
if ((is_array($returnValue)) && (self::$returnArrayAsType == self::RETURN_ARRAY_AS_VALUE)) {
|
||||
return array_shift(PHPExcel_Calculation_Functions::flattenArray($returnValue));
|
||||
}
|
||||
return $returnValue;
|
||||
} else {
|
||||
unset ( $this->_calculationCache [$pCell->getParent ()->getTitle ()] [$pCell->getCoordinate ()] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Formula
|
||||
$formula = $pCell->getValue ();
|
||||
|
||||
// Executable formula array
|
||||
$executableFormulaArray = array ( );
|
||||
|
||||
// Parse formula into a tree of tokens
|
||||
$objParser = new PHPExcel_Calculation_FormulaParser ( $formula );
|
||||
|
||||
// Loop trough parsed tokens and create an executable formula
|
||||
$inFunction = false;
|
||||
$token = null;
|
||||
$tokenCount = $objParser->getTokenCount();
|
||||
for($i = 0; $i < $tokenCount; ++$i) {
|
||||
$token = $objParser->getToken ( $i );
|
||||
$tokenType = $token->getTokenType();
|
||||
$tokenSubType = $token->getTokenSubType();
|
||||
$tokenValue = $token->getValue();
|
||||
|
||||
// Is it a cell reference?
|
||||
if (($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) && ($tokenSubType == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_RANGE)) {
|
||||
// Adjust reference
|
||||
$reference = str_replace ( '$', '', $tokenValue );
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = '$this->extractRange("'.$reference.'", $pCell->getParent())';
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a concatenation operator?
|
||||
if (($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX) && ($tokenSubType == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_CONCATENATION)) {
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = '.';
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a logical operator?
|
||||
if (($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX) && ($tokenSubType == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL)) {
|
||||
// Temporary variable
|
||||
$tmp = '';
|
||||
switch ($tokenValue) {
|
||||
case '=' :
|
||||
$tmp = '==';
|
||||
break;
|
||||
case '<>' :
|
||||
$tmp = '!=';
|
||||
break;
|
||||
default :
|
||||
$tmp = $tokenValue;
|
||||
}
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = $tmp;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a subexpression?
|
||||
if ($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) {
|
||||
// Temporary variable
|
||||
$tmp = '';
|
||||
switch ($tokenSubType) {
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START :
|
||||
$tmp = '(';
|
||||
break;
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP :
|
||||
$tmp = ')';
|
||||
break;
|
||||
}
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = $tmp;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a function?
|
||||
if ($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) {
|
||||
// Temporary variable
|
||||
$tmp = '';
|
||||
|
||||
// Check the function type
|
||||
if ($tokenValue == 'ARRAY' || $tokenValue == 'ARRAYROW') {
|
||||
// An array or an array row...
|
||||
$tmp = 'array(';
|
||||
} else {
|
||||
// A regular function call...
|
||||
switch ($tokenSubType) {
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START :
|
||||
// Check if the function call is allowed...
|
||||
if (! isset ( $this->_functionMappings [strtoupper ($tokenValue)] )) {
|
||||
return '#NAME?';
|
||||
}
|
||||
|
||||
// Map the function call
|
||||
$tmp = $this->_functionMappings [strtoupper ($tokenValue)]->getPHPExcelName () . '(';
|
||||
$inFunction = true;
|
||||
break;
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP :
|
||||
$tmp = ')';
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = $tmp;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it text?
|
||||
if (($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) && ($tokenSubType == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_TEXT)) {
|
||||
// Temporary variable
|
||||
$tmp = $tokenValue;
|
||||
$tmp = str_replace('"', '\"', $tmp);
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = '"'.$tmp.'"';
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a number?
|
||||
if (($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) && ($tokenSubType == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NUMBER)) {
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = $tokenValue;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it an error? Add it as text...
|
||||
if (($tokenType == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) && ($tokenSubType == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_ERROR)) {
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = '"'.$tokenValue.'"';
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it something else?
|
||||
$executableFormulaArray[] = $tokenValue;
|
||||
}
|
||||
|
||||
$fromArray = array('(,', ',,', ',)', '( ,', ', ,', ', )', '$this');
|
||||
$toArray = array('(null,', ',null,', ',null)', '(null,', ',null,', ',null)', '$pThat');
|
||||
// Evaluate formula
|
||||
try {
|
||||
$formula = implode ( ' ', $executableFormulaArray );
|
||||
$formula = str_replace ( $fromArray, $toArray, $formula );
|
||||
|
||||
/*
|
||||
* The following code block can cause an error like:
|
||||
* Fatal error: Unsupported operand types in ...: runtime-created function on line 1
|
||||
*
|
||||
* This is due to the fact that a FATAL error is an E_ERROR,
|
||||
* and it can not be caught using try/catch or any other
|
||||
* Exception/error handling feature in PHP.
|
||||
*
|
||||
* A feature request seems to be made once, but it has been
|
||||
* closed without any deliverables:
|
||||
* http://bugs.php.net/bug.php?id=40014
|
||||
*/
|
||||
$temporaryCalculationFunction = @create_function ( '$pThat, $pCell', "return $formula;" );
|
||||
if ($temporaryCalculationFunction === FALSE) {
|
||||
$returnValue = '#N/A';
|
||||
} else {
|
||||
$calculationExceptionHandler = new PHPExcel_Calculation_ExceptionHandler();
|
||||
$returnValue = $temporaryCalculationFunction ( $this , $pCell );
|
||||
}
|
||||
} catch ( Exception $ex ) {
|
||||
$returnValue = '#N/A';
|
||||
}
|
||||
|
||||
// Save to calculation cache
|
||||
if ($this->getCalculationCacheEnabled ()) {
|
||||
$this->_calculationCache [$pCell->getParent ()->getTitle ()] [$pCell->getCoordinate ()] ['time'] = (time () + microtime ());
|
||||
$this->_calculationCache [$pCell->getParent ()->getTitle ()] [$pCell->getCoordinate ()] ['data'] = $returnValue;
|
||||
}
|
||||
|
||||
// Return result
|
||||
if ((is_array($returnValue)) && (self::$returnArrayAsType == self::RETURN_ARRAY_AS_VALUE)) {
|
||||
return array_shift(PHPExcel_Calculation_Functions::flattenArray($returnValue));
|
||||
}
|
||||
return $returnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* __clone implementation. Cloning should not be allowed in a Singleton!
|
||||
*
|
||||
* @throws Exception
|
||||
*/
|
||||
public final function __clone() {
|
||||
throw new Exception ( "Cloning a Singleton is not allowed!" );
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract range values
|
||||
*
|
||||
* @param string $pRange String based range representation
|
||||
* @param PHPExcel_Worksheet $pSheet Worksheet
|
||||
* @return mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.
|
||||
* @throws Exception
|
||||
*/
|
||||
public function extractRange($pRange = 'A1', PHPExcel_Worksheet $pSheet = null) {
|
||||
// Return value
|
||||
$returnValue = array ( );
|
||||
|
||||
// Worksheet given?
|
||||
if (! is_null ( $pSheet )) {
|
||||
// Worksheet reference?
|
||||
if (strpos ( $pRange, '!' ) !== false) {
|
||||
$worksheetReference = PHPExcel_Worksheet::extractSheetTitle ( $pRange, true );
|
||||
$pSheet = $pSheet->getParent ()->getSheetByName ( $worksheetReference [0] );
|
||||
$pRange = $worksheetReference [1];
|
||||
}
|
||||
|
||||
// Named range?
|
||||
$namedRange = PHPExcel_NamedRange::resolveRange ( $pRange, $pSheet );
|
||||
if (! is_null ( $namedRange )) {
|
||||
$pRange = $namedRange->getRange ();
|
||||
if ($pSheet->getHashCode () != $namedRange->getWorksheet ()->getHashCode ()) {
|
||||
if (! $namedRange->getLocalOnly ()) {
|
||||
$pSheet = $namedRange->getWorksheet ();
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Extract range
|
||||
$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange ( $pRange );
|
||||
if( count ( $aReferences ) == 1 ){
|
||||
return $pSheet->getCell ( $aReferences[0] )->getCalculatedValue ();
|
||||
}
|
||||
|
||||
// Extract cell data
|
||||
foreach ( $aReferences as $reference ) {
|
||||
// Extract range
|
||||
list ( $currentCol, $currentRow ) = PHPExcel_Cell::coordinateFromString ( $reference );
|
||||
|
||||
$returnValue [$currentCol] [$currentRow] = $pSheet->getCell ( $reference )->getCalculatedValue ();
|
||||
}
|
||||
}
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract cell
|
||||
*
|
||||
* @deprecated
|
||||
* @param string $reference
|
||||
* @param PHPExcel_Cell $pCell
|
||||
* @return mixed Value
|
||||
*/
|
||||
public function extractCell($reference = 'A1', PHPExcel_Cell $pCell = null) {
|
||||
$cell = $pCell->getParent ()->getCell ( $reference );
|
||||
if ($cell->getValue () instanceof PHPExcel_RichText) {
|
||||
return $cell->getValue ()->getPlainText ();
|
||||
} else {
|
||||
return $cell->getCalculatedValue ();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Is a specific function implemented?
|
||||
*
|
||||
* @param string $pFunction Function
|
||||
* @return boolean
|
||||
*/
|
||||
public function isImplemented($pFunction = '') {
|
||||
$pFunction = strtoupper ( $pFunction );
|
||||
if (isset ( $this->_functionMappings [$pFunction] )) {
|
||||
return $this->_functionMappings [$pFunction]->getPHPExcelName () == 'PHPExcel_Calculation_Functions::DUMMY';
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of implemented functions
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function listFunctions() {
|
||||
// Return value
|
||||
$returnValue = array();
|
||||
|
||||
// Functions
|
||||
$aFunctions = $this->_functionMappings;
|
||||
// Loop functions
|
||||
foreach ($aFunctions as $function) {
|
||||
if ($function->getPHPExcelName() != 'PHPExcel_Calculation_Functions::DUMMY') {
|
||||
$returnValue[] = $function;
|
||||
}
|
||||
}
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of implemented Excel function names
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function listFunctionNames() {
|
||||
// Return value
|
||||
$returnValue = array();
|
||||
|
||||
// Function names
|
||||
$aFunctions = $this->listFunctions();
|
||||
// Loop functions
|
||||
foreach ($aFunctions as $function) {
|
||||
$returnValue[] = $function->getExcelName();
|
||||
}
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
}
|
||||
}
|
||||
52
include/PHPExcel/PHPExcel/Calculation/Exception.php
Executable file
52
include/PHPExcel/PHPExcel/Calculation/Exception.php
Executable file
@@ -0,0 +1,52 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Calculation_Exception
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Calculation_Exception extends Exception {
|
||||
/**
|
||||
* Error handler callback
|
||||
*
|
||||
* @param mixed $code
|
||||
* @param mixed $string
|
||||
* @param mixed $file
|
||||
* @param mixed $line
|
||||
* @param mixed $context
|
||||
*/
|
||||
public static function errorHandlerCallback($code, $string, $file, $line, $context) {
|
||||
$e = new self($string, $code);
|
||||
$e->line = $line;
|
||||
$e->file = $file;
|
||||
throw $e;
|
||||
}
|
||||
}
|
||||
52
include/PHPExcel/PHPExcel/Calculation/ExceptionHandler.php
Executable file
52
include/PHPExcel/PHPExcel/Calculation/ExceptionHandler.php
Executable file
@@ -0,0 +1,52 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/** PHPExcel_Calculation_Exception */
|
||||
require_once 'PHPExcel/Calculation/Exception.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_Calculation_ExceptionHandler
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Calculation_ExceptionHandler {
|
||||
/**
|
||||
* Register errorhandler
|
||||
*/
|
||||
public function __construct() {
|
||||
set_error_handler(array('PHPExcel_Calculation_Exception', 'errorHandlerCallback'), E_ALL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister errorhandler
|
||||
*/
|
||||
public function __destruct() {
|
||||
restore_error_handler();
|
||||
}
|
||||
}
|
||||
617
include/PHPExcel/PHPExcel/Calculation/FormulaParser.php
Executable file
617
include/PHPExcel/PHPExcel/Calculation/FormulaParser.php
Executable file
@@ -0,0 +1,617 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
PARTLY BASED ON:
|
||||
Copyright (c) 2007 E. W. Bachtal, Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
||||
and associated documentation files (the "Software"), to deal in the Software without restriction,
|
||||
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial
|
||||
portions of the Software.
|
||||
|
||||
The software is provided "as is", without warranty of any kind, express or implied, including but not
|
||||
limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In
|
||||
no event shall the authors or copyright holders be liable for any claim, damages or other liability,
|
||||
whether in an action of contract, tort or otherwise, arising from, out of or in connection with the
|
||||
software or the use or other dealings in the software.
|
||||
|
||||
http://ewbi.blogs.com/develops/2007/03/excel_formula_p.html
|
||||
http://ewbi.blogs.com/develops/2004/12/excel_formula_p.html
|
||||
*/
|
||||
|
||||
/** PHPExcel_Calculation_FormulaToken */
|
||||
require_once 'PHPExcel/Calculation/FormulaToken.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_Calculation_FormulaParser
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Calculation_FormulaParser {
|
||||
/* Character constants */
|
||||
const QUOTE_DOUBLE = '"';
|
||||
const QUOTE_SINGLE = '\'';
|
||||
const BRACKET_CLOSE = ']';
|
||||
const BRACKET_OPEN = '[';
|
||||
const BRACE_OPEN = '{';
|
||||
const BRACE_CLOSE = '}';
|
||||
const PAREN_OPEN = '(';
|
||||
const PAREN_CLOSE = ')';
|
||||
const SEMICOLON = ';';
|
||||
const WHITESPACE = ' ';
|
||||
const COMMA = ',';
|
||||
const ERROR_START = '#';
|
||||
|
||||
const OPERATORS_SN = "+-";
|
||||
const OPERATORS_INFIX = "+-*/^&=><";
|
||||
const OPERATORS_POSTFIX = "%";
|
||||
|
||||
/**
|
||||
* Formula
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_formula;
|
||||
|
||||
/**
|
||||
* Tokens
|
||||
*
|
||||
* @var PHPExcel_Calculation_FormulaToken[]
|
||||
*/
|
||||
private $_tokens = array();
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Calculation_FormulaParser
|
||||
*
|
||||
* @param string $pFormula Formula to parse
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct($pFormula = '')
|
||||
{
|
||||
// Check parameters
|
||||
if (is_null($pFormula)) {
|
||||
throw new Exception("Invalid parameter passed: formula");
|
||||
}
|
||||
|
||||
// Initialise values
|
||||
$this->_formula = trim($pFormula);
|
||||
// Parse!
|
||||
$this->_parseToTokens();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Formula
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getFormula() {
|
||||
return $this->_formula;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Token
|
||||
*
|
||||
* @param int $pId Token id
|
||||
* @return string
|
||||
* @throws Exception
|
||||
*/
|
||||
public function getToken($pId = 0) {
|
||||
if (isset($this->_tokens[$pId])) {
|
||||
return $this->_tokens[$pId];
|
||||
} else {
|
||||
throw new Exception("Token with id $pId does not exist.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Token count
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getTokenCount() {
|
||||
return count($this->_tokens);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Tokens
|
||||
*
|
||||
* @return PHPExcel_Calculation_FormulaToken[]
|
||||
*/
|
||||
public function getTokens() {
|
||||
return $this->_tokens;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse to tokens
|
||||
*/
|
||||
private function _parseToTokens() {
|
||||
// No attempt is made to verify formulas; assumes formulas are derived from Excel, where
|
||||
// they can only exist if valid; stack overflows/underflows sunk as nulls without exceptions.
|
||||
|
||||
// Check if the formula has a valid starting =
|
||||
$formulaLength = strlen($this->_formula);
|
||||
if ($formulaLength < 2 || $this->_formula{0} != '=') return;
|
||||
|
||||
// Helper variables
|
||||
$tokens1 = $tokens2 = $stack = array();
|
||||
$inString = $inPath = $inRange = $inError = false;
|
||||
$token = $previousToken = $nextToken = null;
|
||||
|
||||
$index = 1;
|
||||
$value = '';
|
||||
|
||||
$ERRORS = array("#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A");
|
||||
$COMPARATORS_MULTI = array(">=", "<=", "<>");
|
||||
|
||||
while ($index < $formulaLength) {
|
||||
// state-dependent character evaluation (order is important)
|
||||
|
||||
// double-quoted strings
|
||||
// embeds are doubled
|
||||
// end marks token
|
||||
if ($inString) {
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE) {
|
||||
if ((($index + 2) <= $formulaLength) && ($this->_formula{$index + 1} == PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE)) {
|
||||
$value .= PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE;
|
||||
++$index;
|
||||
} else {
|
||||
$inString = false;
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_TEXT);
|
||||
$value = "";
|
||||
}
|
||||
} else {
|
||||
$value .= $this->_formula{$index};
|
||||
}
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// single-quoted strings (links)
|
||||
// embeds are double
|
||||
// end does not mark a token
|
||||
if ($inPath) {
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE) {
|
||||
if ((($index + 2) <= $formulaLength) && ($this->_formula{$index + 1} == PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE)) {
|
||||
$value .= PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE;
|
||||
++$index;
|
||||
} else {
|
||||
$inPath = false;
|
||||
}
|
||||
} else {
|
||||
$value .= $this->_formula{$index};
|
||||
}
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// bracked strings (R1C1 range index or linked workbook name)
|
||||
// no embeds (changed to "()" by Excel)
|
||||
// end does not mark a token
|
||||
if ($inRange) {
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACKET_CLOSE) {
|
||||
$inRange = false;
|
||||
}
|
||||
$value .= $this->_formula{$index};
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// error values
|
||||
// end marks a token, determined from absolute list of values
|
||||
if ($inError) {
|
||||
$value .= $this->_formula{$index};
|
||||
++$index;
|
||||
if (in_array($value, $ERRORS)) {
|
||||
$inError = false;
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_ERROR);
|
||||
$value = "";
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// scientific notation check
|
||||
if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_SN, $this->_formula{$index}) !== false) {
|
||||
if (strlen($value) > 1) {
|
||||
if (preg_match("/^[1-9]{1}(\.[0-9]+)?E{1}$/", $this->_formula{$index}) != 0) {
|
||||
$value .= $this->_formula{$index};
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// independent character evaluation (order not important)
|
||||
|
||||
// establish state-dependent character evaluations
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE) {
|
||||
if (strlen($value > 0)) { // unexpected
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN);
|
||||
$value = "";
|
||||
}
|
||||
$inString = true;
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE) {
|
||||
if (strlen($value) > 0) { // unexpected
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN);
|
||||
$value = "";
|
||||
}
|
||||
$inPath = true;
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACKET_OPEN) {
|
||||
$inRange = true;
|
||||
$value .= PHPExcel_Calculation_FormulaParser::BRACKET_OPEN;
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::ERROR_START) {
|
||||
if (strlen($value) > 0) { // unexpected
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN);
|
||||
$value = "";
|
||||
}
|
||||
$inError = true;
|
||||
$value .= PHPExcel_Calculation_FormulaParser::ERROR_START;
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// mark start and end of arrays and array rows
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACE_OPEN) {
|
||||
if (strlen($value) > 0) { // unexpected
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN);
|
||||
$value = "";
|
||||
}
|
||||
|
||||
$tmp = new PHPExcel_Calculation_FormulaToken("ARRAY", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START);
|
||||
$tokens1[] = $tmp;
|
||||
$stack[] = clone $tmp;
|
||||
|
||||
$tmp = new PHPExcel_Calculation_FormulaToken("ARRAYROW", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START);
|
||||
$tokens1[] = $tmp;
|
||||
$stack[] = clone $tmp;
|
||||
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::SEMICOLON) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
|
||||
$tmp = array_pop($stack);
|
||||
$tmp->setValue("");
|
||||
$tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP);
|
||||
$tokens1[] = $tmp;
|
||||
|
||||
$tmp = new PHPExcel_Calculation_FormulaToken(",", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_ARGUMENT);
|
||||
$tokens1[] = $tmp;
|
||||
|
||||
$tmp = new PHPExcel_Calculation_FormulaToken("ARRAYROW", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START);
|
||||
$tokens1[] = $tmp;
|
||||
$stack[] = clone $tmp;
|
||||
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACE_CLOSE) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
|
||||
$tmp = array_pop($stack);
|
||||
$tmp->setValue("");
|
||||
$tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP);
|
||||
$tokens1[] = $tmp;
|
||||
|
||||
$tmp = array_pop($stack);
|
||||
$tmp->setValue("");
|
||||
$tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP);
|
||||
$tokens1[] = $tmp;
|
||||
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// trim white-space
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::WHITESPACE) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken("", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_WHITESPACE);
|
||||
++$index;
|
||||
while (($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::WHITESPACE) && ($index < $formulaLength)) {
|
||||
++$index;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// multi-character comparators
|
||||
if (($index + 2) <= $formulaLength) {
|
||||
if (in_array(substr($this->_formula, $index, 2), $COMPARATORS_MULTI)) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken(substr($this->_formula, $index, 2), PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL);
|
||||
$index += 2;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// standard infix operators
|
||||
if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_INFIX, $this->_formula{$index}) !== false) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] =new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($this->_formula{$index}, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX);
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// standard postfix operators (only one)
|
||||
if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_POSTFIX, $this->_formula{$index}) !== false) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($this->_formula{$index}, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX);
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// start subexpression or function
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::PAREN_OPEN) {
|
||||
if (strlen($value) > 0) {
|
||||
$tmp = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START);
|
||||
$tokens1[] = $tmp;
|
||||
$stack[] = clone $tmp;
|
||||
$value = "";
|
||||
} else {
|
||||
$tmp = new PHPExcel_Calculation_FormulaToken("", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START);
|
||||
$tokens1[] = $tmp;
|
||||
$stack[] = clone $tmp;
|
||||
}
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// function, subexpression, or array parameters, or operand unions
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::COMMA) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
|
||||
$tmp = array_pop($stack);
|
||||
$tmp->setValue("");
|
||||
$tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP);
|
||||
$stack[] = $tmp;
|
||||
|
||||
if ($tmp->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken(",", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_UNION);
|
||||
} else {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken(",", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_ARGUMENT);
|
||||
}
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// stop subexpression
|
||||
if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::PAREN_CLOSE) {
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
$value = "";
|
||||
}
|
||||
|
||||
$tmp = array_pop($stack);
|
||||
$tmp->setValue("");
|
||||
$tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP);
|
||||
$tokens1[] = $tmp;
|
||||
|
||||
++$index;
|
||||
continue;
|
||||
}
|
||||
|
||||
// token accumulation
|
||||
$value .= $this->_formula{$index};
|
||||
++$index;
|
||||
}
|
||||
|
||||
// dump remaining accumulation
|
||||
if (strlen($value) > 0) {
|
||||
$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
|
||||
}
|
||||
|
||||
// move tokenList to new set, excluding unnecessary white-space tokens and converting necessary ones to intersections
|
||||
$tokenCount = count($tokens1);
|
||||
for ($i = 0; $i < $tokenCount; ++$i) {
|
||||
$token = $tokens1[$i];
|
||||
if (isset($tokens1[$i - 1])) {
|
||||
$previousToken = $tokens1[$i - 1];
|
||||
} else {
|
||||
$previousToken = null;
|
||||
}
|
||||
if (isset($tokens1[$i + 1])) {
|
||||
$nextToken = $tokens1[$i + 1];
|
||||
} else {
|
||||
$nextToken = null;
|
||||
}
|
||||
|
||||
if (is_null($token)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->getTokenType() != PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_WHITESPACE) {
|
||||
$tokens2[] = $token;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (is_null($previousToken)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (! (
|
||||
(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
|
||||
(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
|
||||
($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND)
|
||||
) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (is_null($nextToken)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (! (
|
||||
(($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($nextToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START)) ||
|
||||
(($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($nextToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START)) ||
|
||||
($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND)
|
||||
) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$tokens2[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_INTERSECTION);
|
||||
}
|
||||
|
||||
// move tokens to final list, switching infix "-" operators to prefix when appropriate, switching infix "+" operators
|
||||
// to noop when appropriate, identifying operand and infix-operator subtypes, and pulling "@" from function names
|
||||
$this->_tokens = array();
|
||||
|
||||
$tokenCount = count($tokens2);
|
||||
for ($i = 0; $i < $tokenCount; ++$i) {
|
||||
$token = $tokens2[$i];
|
||||
if (isset($tokens2[$i - 1])) {
|
||||
$previousToken = $tokens2[$i - 1];
|
||||
} else {
|
||||
$previousToken = null;
|
||||
}
|
||||
if (isset($tokens2[$i + 1])) {
|
||||
$nextToken = $tokens2[$i + 1];
|
||||
} else {
|
||||
$nextToken = null;
|
||||
}
|
||||
|
||||
if (is_null($token)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getValue() == "-") {
|
||||
if ($i == 0) {
|
||||
$token->setTokenType(PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPREFIX);
|
||||
} else if (
|
||||
(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
|
||||
(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
|
||||
($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX) ||
|
||||
($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND)
|
||||
) {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_MATH);
|
||||
} else {
|
||||
$token->setTokenType(PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPREFIX);
|
||||
}
|
||||
|
||||
$this->_tokens[] = $token;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getValue() == "+") {
|
||||
if ($i == 0) {
|
||||
continue;
|
||||
} else if (
|
||||
(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
|
||||
(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
|
||||
($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX) ||
|
||||
($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND)
|
||||
) {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_MATH);
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
|
||||
$this->_tokens[] = $token;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING) {
|
||||
if (strpos("<>=", substr($token->getValue(), 0, 1)) !== false) {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL);
|
||||
} else if ($token->getValue() == "&") {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_CONCATENATION);
|
||||
} else {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_MATH);
|
||||
}
|
||||
|
||||
$this->_tokens[] = $token;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND && $token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING) {
|
||||
if (!is_numeric($token->getValue())) {
|
||||
if (strtoupper($token->getValue()) == "TRUE" || strtoupper($token->getValue() == "FALSE")) {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL);
|
||||
} else {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_RANGE);
|
||||
}
|
||||
} else {
|
||||
$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NUMBER);
|
||||
}
|
||||
|
||||
$this->_tokens[] = $token;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) {
|
||||
if (strlen($token->getValue() > 0)) {
|
||||
if (substr($token->getValue(), 0, 1) == "@") {
|
||||
$token->setValue(substr($token->getValue(), 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$this->_tokens[] = $token;
|
||||
}
|
||||
}
|
||||
}
|
||||
176
include/PHPExcel/PHPExcel/Calculation/FormulaToken.php
Executable file
176
include/PHPExcel/PHPExcel/Calculation/FormulaToken.php
Executable file
@@ -0,0 +1,176 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
PARTLY BASED ON:
|
||||
Copyright (c) 2007 E. W. Bachtal, Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
||||
and associated documentation files (the "Software"), to deal in the Software without restriction,
|
||||
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial
|
||||
portions of the Software.
|
||||
|
||||
The software is provided "as is", without warranty of any kind, express or implied, including but not
|
||||
limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In
|
||||
no event shall the authors or copyright holders be liable for any claim, damages or other liability,
|
||||
whether in an action of contract, tort or otherwise, arising from, out of or in connection with the
|
||||
software or the use or other dealings in the software.
|
||||
|
||||
http://ewbi.blogs.com/develops/2007/03/excel_formula_p.html
|
||||
http://ewbi.blogs.com/develops/2004/12/excel_formula_p.html
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Calculation_FormulaToken
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Calculation_FormulaToken {
|
||||
/* Token types */
|
||||
const TOKEN_TYPE_NOOP = 'Noop';
|
||||
const TOKEN_TYPE_OPERAND = 'Operand';
|
||||
const TOKEN_TYPE_FUNCTION = 'Function';
|
||||
const TOKEN_TYPE_SUBEXPRESSION = 'Subexpression';
|
||||
const TOKEN_TYPE_ARGUMENT = 'Argument';
|
||||
const TOKEN_TYPE_OPERATORPREFIX = 'OperatorPrefix';
|
||||
const TOKEN_TYPE_OPERATORINFIX = 'OperatorInfix';
|
||||
const TOKEN_TYPE_OPERATORPOSTFIX = 'OperatorPostfix';
|
||||
const TOKEN_TYPE_WHITESPACE = 'Whitespace';
|
||||
const TOKEN_TYPE_UNKNOWN = 'Unknown';
|
||||
|
||||
/* Token subtypes */
|
||||
const TOKEN_SUBTYPE_NOTHING = 'Nothing';
|
||||
const TOKEN_SUBTYPE_START = 'Start';
|
||||
const TOKEN_SUBTYPE_STOP = 'Stop';
|
||||
const TOKEN_SUBTYPE_TEXT = 'Text';
|
||||
const TOKEN_SUBTYPE_NUMBER = 'Number';
|
||||
const TOKEN_SUBTYPE_LOGICAL = 'Logical';
|
||||
const TOKEN_SUBTYPE_ERROR = 'Error';
|
||||
const TOKEN_SUBTYPE_RANGE = 'Range';
|
||||
const TOKEN_SUBTYPE_MATH = 'Math';
|
||||
const TOKEN_SUBTYPE_CONCATENATION = 'Concatenation';
|
||||
const TOKEN_SUBTYPE_INTERSECTION = 'Intersection';
|
||||
const TOKEN_SUBTYPE_UNION = 'Union';
|
||||
|
||||
/**
|
||||
* Value
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_value;
|
||||
|
||||
/**
|
||||
* Token Type (represented by TOKEN_TYPE_*)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_tokenType;
|
||||
|
||||
/**
|
||||
* Token SubType (represented by TOKEN_SUBTYPE_*)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_tokenSubType;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Calculation_FormulaToken
|
||||
*
|
||||
* @param string $pValue
|
||||
* @param string $pTokenType Token type (represented by TOKEN_TYPE_*)
|
||||
* @param string $pTokenSubType Token Subtype (represented by TOKEN_SUBTYPE_*)
|
||||
*/
|
||||
public function __construct($pValue, $pTokenType = PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN, $pTokenSubType = PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING)
|
||||
{
|
||||
// Initialise values
|
||||
$this->_value = $pValue;
|
||||
$this->_tokenType = $pTokenType;
|
||||
$this->_tokenSubType = $pTokenSubType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Value
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getValue() {
|
||||
return $this->_value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Value
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setValue($value) {
|
||||
$this->_value = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Token Type (represented by TOKEN_TYPE_*)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getTokenType() {
|
||||
return $this->_tokenType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Token Type
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setTokenType($value = PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN) {
|
||||
$this->_tokenType = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Token SubType (represented by TOKEN_SUBTYPE_*)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getTokenSubType() {
|
||||
return $this->_tokenSubType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Token SubType
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setTokenSubType($value = PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING) {
|
||||
$this->_tokenSubType = $value;
|
||||
}
|
||||
}
|
||||
149
include/PHPExcel/PHPExcel/Calculation/Function.php
Executable file
149
include/PHPExcel/PHPExcel/Calculation/Function.php
Executable file
@@ -0,0 +1,149 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Calculation_Function
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Calculation
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Calculation_Function {
|
||||
/* Function categories */
|
||||
const CATEGORY_CUBE = 'Cube';
|
||||
const CATEGORY_DATABASE = 'Database';
|
||||
const CATEGORY_DATE_AND_TIME = 'Date and Time';
|
||||
const CATEGORY_ENGINEERING = 'Engineering';
|
||||
const CATEGORY_FINANCIAL = 'Financial';
|
||||
const CATEGORY_INFORMATION = 'Information';
|
||||
const CATEGORY_LOGICAL = 'Logical';
|
||||
const CATEGORY_LOOKUP_AND_REFERENCE = 'Lookup and Reference';
|
||||
const CATEGORY_MATH_AND_TRIG = 'Math and Trig';
|
||||
const CATEGORY_STATISTICAL = 'Statistical';
|
||||
const CATEGORY_TEXT_AND_DATA = 'Text and Data';
|
||||
|
||||
/**
|
||||
* Category (represented by CATEGORY_*)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_category;
|
||||
|
||||
/**
|
||||
* Excel name
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_excelName;
|
||||
|
||||
/**
|
||||
* PHPExcel name
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_phpExcelName;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Calculation_Function
|
||||
*
|
||||
* @param string $pCategory Category (represented by CATEGORY_*)
|
||||
* @param string $pExcelName Excel function name
|
||||
* @param string $pPHPExcelName PHPExcel function mapping
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct($pCategory = null, $pExcelName = null, $pPHPExcelName = null)
|
||||
{
|
||||
if (!is_null($pCategory) && !is_null($pExcelName) && !is_null($pPHPExcelName)) {
|
||||
// Initialise values
|
||||
$this->_category = $pCategory;
|
||||
$this->_excelName = $pExcelName;
|
||||
$this->_phpExcelName = $pPHPExcelName;
|
||||
} else {
|
||||
throw new Exception("Invalid parameters passed.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Category (represented by CATEGORY_*)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getCategory() {
|
||||
return $this->_category;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Category (represented by CATEGORY_*)
|
||||
*
|
||||
* @param string $value
|
||||
* @throws Exception
|
||||
*/
|
||||
public function setCategory($value = null) {
|
||||
if (!is_null($value)) {
|
||||
$this->_category = $value;
|
||||
} else {
|
||||
throw new Exception("Invalid parameter passed.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Excel name
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getExcelName() {
|
||||
return $this->_excelName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Excel name
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setExcelName($value) {
|
||||
$this->_excelName = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get PHPExcel name
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getPHPExcelName() {
|
||||
return $this->_phpExcelName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set PHPExcel name
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setPHPExcelName($value) {
|
||||
$this->_phpExcelName = $value;
|
||||
}
|
||||
}
|
||||
9542
include/PHPExcel/PHPExcel/Calculation/Functions.php
Executable file
9542
include/PHPExcel/PHPExcel/Calculation/Functions.php
Executable file
File diff suppressed because it is too large
Load Diff
721
include/PHPExcel/PHPExcel/Cell.php
Executable file
721
include/PHPExcel/PHPExcel/Cell.php
Executable file
@@ -0,0 +1,721 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell_DataType */
|
||||
require_once 'PHPExcel/Cell/DataType.php';
|
||||
|
||||
/** PHPExcel_Cell_DataValidation */
|
||||
require_once 'PHPExcel/Cell/DataValidation.php';
|
||||
|
||||
/** PHPExcel_Cell_Hyperlink */
|
||||
require_once 'PHPExcel/Cell/Hyperlink.php';
|
||||
|
||||
/** PHPExcel_Worksheet */
|
||||
require_once 'PHPExcel/Worksheet.php';
|
||||
|
||||
/** PHPExcel_Calculation */
|
||||
require_once 'PHPExcel/Calculation.php';
|
||||
|
||||
/** PHPExcel_Cell_IValueBinder */
|
||||
require_once 'PHPExcel/Cell/IValueBinder.php';
|
||||
|
||||
/** PHPExcel_Cell_DefaultValueBinder */
|
||||
require_once 'PHPExcel/Cell/DefaultValueBinder.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Cell
|
||||
{
|
||||
/**
|
||||
* Value binder to use
|
||||
*
|
||||
* @var PHPExcel_Cell_IValueBinder
|
||||
*/
|
||||
private static $_valueBinder = null;
|
||||
|
||||
/**
|
||||
* Column of the cell
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_column;
|
||||
|
||||
/**
|
||||
* Row of the cell
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_row;
|
||||
|
||||
/**
|
||||
* Value of the cell
|
||||
*
|
||||
* @var mixed
|
||||
*/
|
||||
private $_value;
|
||||
|
||||
/**
|
||||
* Calculated value of the cell (used for caching)
|
||||
*
|
||||
* @var mixed
|
||||
*/
|
||||
private $_calculatedValue = null;
|
||||
|
||||
/**
|
||||
* Type of the cell data
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_dataType;
|
||||
|
||||
/**
|
||||
* Data validation
|
||||
*
|
||||
* @var PHPExcel_Cell_DataValidation
|
||||
*/
|
||||
private $_dataValidation;
|
||||
|
||||
/**
|
||||
* Hyperlink
|
||||
*
|
||||
* @var PHPExcel_Cell_Hyperlink
|
||||
*/
|
||||
private $_hyperlink;
|
||||
|
||||
/**
|
||||
* Parent worksheet
|
||||
*
|
||||
* @var PHPExcel_Worksheet
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* Create a new Cell
|
||||
*
|
||||
* @param string $pColumn
|
||||
* @param int $pRow
|
||||
* @param mixed $pValue
|
||||
* @param string $pDataType
|
||||
* @param PHPExcel_Worksheet $pSheet
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct($pColumn = 'A', $pRow = 1, $pValue = null, $pDataType = null, PHPExcel_Worksheet $pSheet = null)
|
||||
{
|
||||
// Set value binder?
|
||||
if (is_null(self::$_valueBinder)) {
|
||||
self::$_valueBinder = new PHPExcel_Cell_DefaultValueBinder();
|
||||
}
|
||||
|
||||
// Initialise cell coordinate
|
||||
$this->_column = strtoupper($pColumn);
|
||||
$this->_row = $pRow;
|
||||
|
||||
// Initialise cell value
|
||||
$this->_value = $pValue;
|
||||
|
||||
// Set worksheet
|
||||
$this->_parent = $pSheet;
|
||||
|
||||
// Set datatype?
|
||||
if (!is_null($pDataType)) {
|
||||
$this->_dataType = $pDataType;
|
||||
} else {
|
||||
if (!self::getValueBinder()->bindValue($this, $pValue)) {
|
||||
throw new Exception("Value could not be bound to cell.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell coordinate column
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getColumn()
|
||||
{
|
||||
return strtoupper($this->_column);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell coordinate row
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getRow()
|
||||
{
|
||||
return $this->_row;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell coordinate
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getCoordinate()
|
||||
{
|
||||
return $this->_column . $this->_row;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell value
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function getValue()
|
||||
{
|
||||
return $this->_value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set cell value
|
||||
*
|
||||
* This clears the cell formula.
|
||||
*
|
||||
* @param mixed $pValue Value
|
||||
* @param bool $pUpdateDataType Update the data type?
|
||||
*/
|
||||
public function setValue($pValue = null, $pUpdateDataType = true)
|
||||
{
|
||||
$this->_value = $pValue;
|
||||
|
||||
if ($pUpdateDataType) {
|
||||
if (!self::getValueBinder()->bindValue($this, $pValue)) {
|
||||
throw new Exception("Value could not be bound to cell.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set cell value (with explicit data type given)
|
||||
*
|
||||
* @param mixed $pValue Value
|
||||
* @param string $pDataType Explicit data type
|
||||
*/
|
||||
public function setValueExplicit($pValue = null, $pDataType = PHPExcel_Cell_DataType::TYPE_STRING)
|
||||
{
|
||||
$this->_value = $pValue;
|
||||
$this->_dataType = $pDataType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get caluclated cell value
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function getCalculatedValue()
|
||||
{
|
||||
if (!is_null($this->_calculatedValue) && $this->_dataType == PHPExcel_Cell_DataType::TYPE_FORMULA) {
|
||||
try {
|
||||
$result = PHPExcel_Calculation::getInstance()->calculate($this);
|
||||
} catch ( Exception $ex ) {
|
||||
$result = '#N/A';
|
||||
}
|
||||
|
||||
if ((is_string($result)) && ($result == '#Not Yet Implemented')) {
|
||||
return $this->_calculatedValue; // Fallback if calculation engine does not support the formula.
|
||||
} else {
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_null($this->_value) || $this->_value === '') {
|
||||
} else if ($this->_dataType != PHPExcel_Cell_DataType::TYPE_FORMULA) {
|
||||
return $this->_value;
|
||||
} else {
|
||||
return PHPExcel_Calculation::getInstance()->calculate($this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set calculated value (used for caching)
|
||||
*
|
||||
* @param mixed $pValue Value
|
||||
*/
|
||||
public function setCalculatedValue($pValue = null)
|
||||
{
|
||||
if (!is_null($pValue)) {
|
||||
$this->_calculatedValue = $pValue;
|
||||
}
|
||||
}
|
||||
|
||||
public function getOldCalculatedValue()
|
||||
{
|
||||
return $this->_calculatedValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell data type
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getDataType()
|
||||
{
|
||||
return $this->_dataType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set cell data type
|
||||
*
|
||||
* @param string $pDataType
|
||||
*/
|
||||
public function setDataType($pDataType = PHPExcel_Cell_DataType::TYPE_STRING)
|
||||
{
|
||||
$this->_dataType = $pDataType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Has Data validation?
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function hasDataValidation()
|
||||
{
|
||||
return !is_null($this->_dataValidation);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Data validation
|
||||
*
|
||||
* @return PHPExcel_Cell_DataValidation
|
||||
*/
|
||||
public function getDataValidation()
|
||||
{
|
||||
if (is_null($this->_dataValidation)) {
|
||||
$this->_dataValidation = new PHPExcel_Cell_DataValidation($this);
|
||||
}
|
||||
|
||||
return $this->_dataValidation;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Data validation
|
||||
*
|
||||
* @param PHPExcel_Cell_DataValidation $pDataValidation
|
||||
* @throws Exception
|
||||
*/
|
||||
public function setDataValidation(PHPExcel_Cell_DataValidation $pDataValidation = null)
|
||||
{
|
||||
$this->_dataValidation = $pDataValidation;
|
||||
$this->_dataValidation->setParent($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Has Hyperlink
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function hasHyperlink()
|
||||
{
|
||||
return !is_null($this->_hyperlink);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Hyperlink
|
||||
*
|
||||
* @return PHPExcel_Cell_Hyperlink
|
||||
*/
|
||||
public function getHyperlink()
|
||||
{
|
||||
if (is_null($this->_hyperlink)) {
|
||||
$this->_hyperlink = new PHPExcel_Cell_Hyperlink($this);
|
||||
}
|
||||
|
||||
return $this->_hyperlink;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Hyperlink
|
||||
*
|
||||
* @param PHPExcel_Cell_Hyperlink $pHyperlink
|
||||
* @throws Exception
|
||||
*/
|
||||
public function setHyperlink(PHPExcel_Cell_Hyperlink $pHyperlink = null)
|
||||
{
|
||||
$this->_hyperlink = $pHyperlink;
|
||||
$this->_hyperlink->setParent($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parent
|
||||
*
|
||||
* @return PHPExcel_Worksheet
|
||||
*/
|
||||
public function getParent() {
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-bind parent
|
||||
*
|
||||
* @param PHPExcel_Worksheet $parent
|
||||
*/
|
||||
public function rebindParent(PHPExcel_Worksheet $parent) {
|
||||
$this->_parent = $parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is cell in a specific range?
|
||||
*
|
||||
* @param string $pRange Cell range (e.g. A1:A1)
|
||||
* @return boolean
|
||||
*/
|
||||
public function isInRange($pRange = 'A1:A1')
|
||||
{
|
||||
// Uppercase coordinate
|
||||
$pRange = strtoupper($pRange);
|
||||
|
||||
// Extract range
|
||||
$rangeA = '';
|
||||
$rangeB = '';
|
||||
if (strpos($pRange, ':') === false) {
|
||||
$rangeA = $pRange;
|
||||
$rangeB = $pRange;
|
||||
} else {
|
||||
list($rangeA, $rangeB) = explode(':', $pRange);
|
||||
}
|
||||
|
||||
// Calculate range outer borders
|
||||
$rangeStart = PHPExcel_Cell::coordinateFromString($rangeA);
|
||||
$rangeEnd = PHPExcel_Cell::coordinateFromString($rangeB);
|
||||
|
||||
// Translate column into index
|
||||
$rangeStart[0] = PHPExcel_Cell::columnIndexFromString($rangeStart[0]) - 1;
|
||||
$rangeEnd[0] = PHPExcel_Cell::columnIndexFromString($rangeEnd[0]) - 1;
|
||||
|
||||
// Translate properties
|
||||
$myColumn = PHPExcel_Cell::columnIndexFromString($this->getColumn()) - 1;
|
||||
$myRow = $this->getRow();
|
||||
|
||||
// Verify if cell is in range
|
||||
return (
|
||||
($rangeStart[0] <= $myColumn && $rangeEnd[0] >= $myColumn) &&
|
||||
($rangeStart[1] <= $myRow && $rangeEnd[1] >= $myRow)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Coordinate from string
|
||||
*
|
||||
* @param string $pCoordinateString
|
||||
* @return array Array containing column and row (indexes 0 and 1)
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function coordinateFromString($pCoordinateString = 'A1')
|
||||
{
|
||||
if (strpos($pCoordinateString,':') !== false) {
|
||||
throw new Exception('Cell coordinate string can not be a range of cells.');
|
||||
} else if ($pCoordinateString == '') {
|
||||
throw new Exception('Cell coordinate can not be zero-length string.');
|
||||
} else {
|
||||
// Column
|
||||
$column = '';
|
||||
|
||||
// Row
|
||||
$row = '';
|
||||
|
||||
// Convert a cell reference
|
||||
if (preg_match("/([$]?[A-Z]+)([$]?\d+)/", $pCoordinateString, $matches)) {
|
||||
list(, $column, $row) = $matches;
|
||||
}
|
||||
|
||||
// Return array
|
||||
return array($column, $row);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Make string coordinate absolute
|
||||
*
|
||||
* @param string $pCoordinateString
|
||||
* @return string Absolute coordinate
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function absoluteCoordinate($pCoordinateString = 'A1')
|
||||
{
|
||||
if (strpos($pCoordinateString,':') === false && strpos($pCoordinateString,',') === false) {
|
||||
// Return value
|
||||
$returnValue = '';
|
||||
|
||||
// Create absolute coordinate
|
||||
list($column, $row) = PHPExcel_Cell::coordinateFromString($pCoordinateString);
|
||||
$returnValue = '$' . $column . '$' . $row;
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
} else {
|
||||
throw new Exception("Coordinate string should not be a cell range.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Split range into coordinate strings
|
||||
*
|
||||
* @param string $pRange
|
||||
* @return array Array containg one or more arrays containing one or two coordinate strings
|
||||
*/
|
||||
public static function splitRange($pRange = 'A1:A1')
|
||||
{
|
||||
$exploded = explode(',', $pRange);
|
||||
for ($i = 0; $i < count($exploded); $i++) {
|
||||
$exploded[$i] = explode(':', $exploded[$i]);
|
||||
}
|
||||
return $exploded;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build range from coordinate strings
|
||||
*
|
||||
* @param array $pRange Array containg one or more arrays containing one or two coordinate strings
|
||||
* @return string String representation of $pRange
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function buildRange($pRange)
|
||||
{
|
||||
// Verify range
|
||||
if (!is_array($pRange) || count($pRange) == 0 || !is_array($pRange[0])) {
|
||||
throw new Exception('Range does not contain any information.');
|
||||
}
|
||||
|
||||
// Build range
|
||||
$imploded = array();
|
||||
for ($i = 0; $i < count($pRange); $i++) {
|
||||
$pRange[$i] = implode(':', $pRange[$i]);
|
||||
}
|
||||
$imploded = implode(',', $pRange);
|
||||
|
||||
return $imploded;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate range dimension
|
||||
*
|
||||
* @param string $pRange Cell range (e.g. A1:A1)
|
||||
* @return array Range dimension (width, height)
|
||||
*/
|
||||
public static function rangeDimension($pRange = 'A1:A1')
|
||||
{
|
||||
// Uppercase coordinate
|
||||
$pRange = strtoupper($pRange);
|
||||
|
||||
// Extract range
|
||||
$rangeA = '';
|
||||
$rangeB = '';
|
||||
if (strpos($pRange, ':') === false) {
|
||||
$rangeA = $pRange;
|
||||
$rangeB = $pRange;
|
||||
} else {
|
||||
list($rangeA, $rangeB) = explode(':', $pRange);
|
||||
}
|
||||
|
||||
// Calculate range outer borders
|
||||
$rangeStart = PHPExcel_Cell::coordinateFromString($rangeA);
|
||||
$rangeEnd = PHPExcel_Cell::coordinateFromString($rangeB);
|
||||
|
||||
// Translate column into index
|
||||
$rangeStart[0] = PHPExcel_Cell::columnIndexFromString($rangeStart[0]);
|
||||
$rangeEnd[0] = PHPExcel_Cell::columnIndexFromString($rangeEnd[0]);
|
||||
|
||||
return array( ($rangeEnd[0] - $rangeStart[0] + 1), ($rangeEnd[1] - $rangeStart[1] + 1) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Column index from string
|
||||
*
|
||||
* @param string $pString
|
||||
* @return int Column index (base 1 !!!)
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function columnIndexFromString($pString = 'A')
|
||||
{
|
||||
// Convert to uppercase
|
||||
$pString = strtoupper($pString);
|
||||
|
||||
$strLen = strlen($pString);
|
||||
// Convert column to integer
|
||||
if ($strLen == 1) {
|
||||
return (ord($pString{0}) - 64);
|
||||
} elseif ($strLen == 2) {
|
||||
return $result = ((1 + (ord($pString{0}) - 65)) * 26) + (ord($pString{1}) - 64);
|
||||
} elseif ($strLen == 3) {
|
||||
return ((1 + (ord($pString{0}) - 65)) * 676) + ((1 + (ord($pString{1}) - 65)) * 26) + (ord($pString{2}) - 64);
|
||||
} else {
|
||||
throw new Exception("Column string index can not be " . ($strLen != 0 ? "longer than 3 characters" : "empty") . ".");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* String from columnindex
|
||||
*
|
||||
* @param int $pColumnIndex Column index (base 0 !!!)
|
||||
* @return string
|
||||
*/
|
||||
public static function stringFromColumnIndex($pColumnIndex = 0)
|
||||
{
|
||||
// Determine column string
|
||||
if ($pColumnIndex < 26) {
|
||||
return chr(65 + $pColumnIndex);
|
||||
}
|
||||
return PHPExcel_Cell::stringFromColumnIndex((int)($pColumnIndex / 26) -1).chr(65 + $pColumnIndex%26) ;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) = PHPExcel_Cell::coordinateFromString($explodedSpaces);
|
||||
|
||||
if (strlen($col) <= 2) {
|
||||
$returnValue[] = $explodedSpaces;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Range...
|
||||
$range = PHPExcel_Cell::splitRange($explodedSpaces);
|
||||
for ($i = 0; $i < count($range); $i++) {
|
||||
// Single cell?
|
||||
if (count($range[$i]) == 1) {
|
||||
$col = 'A';
|
||||
$row = 1;
|
||||
list($col, $row) = PHPExcel_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) = PHPExcel_Cell::coordinateFromString($rangeStart);
|
||||
list($endingCol, $endingRow) = PHPExcel_Cell::coordinateFromString($rangeEnd);
|
||||
|
||||
// Conversions...
|
||||
$startingCol = PHPExcel_Cell::columnIndexFromString($startingCol);
|
||||
$endingCol = PHPExcel_Cell::columnIndexFromString($endingCol);
|
||||
|
||||
// Current data
|
||||
$currentCol = --$startingCol;
|
||||
$currentRow = $startingRow;
|
||||
|
||||
// Loop cells
|
||||
while ($currentCol < $endingCol) {
|
||||
$loopColumn = PHPExcel_Cell::stringFromColumnIndex($currentCol);
|
||||
while ($currentRow <= $endingRow) {
|
||||
$returnValue[] = $loopColumn.$currentRow;
|
||||
++$currentRow;
|
||||
}
|
||||
++$currentCol;
|
||||
$currentRow = $startingRow;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return value
|
||||
return $returnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare 2 cells
|
||||
*
|
||||
* @param PHPExcel_Cell $a Cell a
|
||||
* @param PHPExcel_Cell $a Cell b
|
||||
* @return int Result of comparison (always -1 or 1, never zero!)
|
||||
*/
|
||||
public static function compareCells(PHPExcel_Cell $a, PHPExcel_Cell $b)
|
||||
{
|
||||
if ($a->_row < $b->_row) {
|
||||
return -1;
|
||||
} elseif ($a->_row > $b->_row) {
|
||||
return 1;
|
||||
} elseif (PHPExcel_Cell::columnIndexFromString($a->_column) < PHPExcel_Cell::columnIndexFromString($b->_column)) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get value binder to use
|
||||
*
|
||||
* @return PHPExcel_Cell_IValueBinder
|
||||
*/
|
||||
public static function getValueBinder() {
|
||||
return self::$_valueBinder;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set value binder to use
|
||||
*
|
||||
* @param PHPExcel_Cell_IValueBinder $binder
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function setValueBinder(PHPExcel_Cell_IValueBinder $binder = null) {
|
||||
if (is_null($binder)) {
|
||||
throw new Exception("A PHPExcel_Cell_IValueBinder is required for PHPExcel to function correctly.");
|
||||
}
|
||||
|
||||
self::$_valueBinder = $binder;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
108
include/PHPExcel/PHPExcel/Cell/AdvancedValueBinder.php
Executable file
108
include/PHPExcel/PHPExcel/Cell/AdvancedValueBinder.php
Executable file
@@ -0,0 +1,108 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_Cell_IValueBinder */
|
||||
require_once 'PHPExcel/Cell/IValueBinder.php';
|
||||
|
||||
/** PHPExcel_Cell_DefaultValueBinder */
|
||||
require_once 'PHPExcel/Cell/DefaultValueBinder.php';
|
||||
|
||||
/** PHPExcel_Style_NumberFormat */
|
||||
require_once 'PHPExcel/Style/NumberFormat.php';
|
||||
|
||||
/** PHPExcel_Shared_Date */
|
||||
require_once 'PHPExcel/Shared/Date.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell_AdvancedValueBinder
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Cell_AdvancedValueBinder extends PHPExcel_Cell_DefaultValueBinder implements PHPExcel_Cell_IValueBinder
|
||||
{
|
||||
/**
|
||||
* 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)
|
||||
{
|
||||
// Find out data type
|
||||
$dataType = parent::dataTypeForValue($value);
|
||||
|
||||
// Style logic - strings
|
||||
if ($dataType === PHPExcel_Cell_DataType::TYPE_STRING && !$value instanceof PHPExcel_RichText) {
|
||||
// Check for percentage
|
||||
if (preg_match('/^\-?[0-9]*\.?[0-9]*\s?\%$/', $value)) {
|
||||
// Convert value to number
|
||||
$cell->setValueExplicit( (float)str_replace('%', '', $value) / 100, PHPExcel_Cell_DataType::TYPE_NUMERIC);
|
||||
|
||||
// Set style
|
||||
$cell->getParent()->getStyle( $cell->getCoordinate() )->getNumberFormat()->setFormatCode( PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Check for date
|
||||
if (strtotime($value) !== false) {
|
||||
// Convert value to Excel date
|
||||
$cell->setValueExplicit( PHPExcel_Shared_Date::PHPToExcel(strtotime($value)), PHPExcel_Cell_DataType::TYPE_NUMERIC);
|
||||
|
||||
// Set style
|
||||
$cell->getParent()->getStyle( $cell->getCoordinate() )->getNumberFormat()->setFormatCode( PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD2 );
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Style logic - Numbers
|
||||
if ($dataType === PHPExcel_Cell_DataType::TYPE_NUMERIC) {
|
||||
// Leading zeroes?
|
||||
if (preg_match('/^\-?[0]+[0-9]*\.?[0-9]*$/', $value)) {
|
||||
// Convert value to string
|
||||
$cell->setValueExplicit( $value, PHPExcel_Cell_DataType::TYPE_STRING);
|
||||
|
||||
// Set style
|
||||
$cell->getParent()->getStyle( $cell->getCoordinate() )->getNumberFormat()->setFormatCode( PHPExcel_Style_NumberFormat::FORMAT_TEXT );
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Not bound yet? Use parent...
|
||||
return parent::bindValue($cell, $value);
|
||||
}
|
||||
}
|
||||
77
include/PHPExcel/PHPExcel/Cell/DataType.php
Executable file
77
include/PHPExcel/PHPExcel/Cell/DataType.php
Executable file
@@ -0,0 +1,77 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell_DefaultValueBinder */
|
||||
require_once 'PHPExcel/Cell/DefaultValueBinder.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell_DataType
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Cell_DataType
|
||||
{
|
||||
/* Data types */
|
||||
const TYPE_STRING = 's';
|
||||
const TYPE_FORMULA = 'f';
|
||||
const TYPE_NUMERIC = 'n';
|
||||
const TYPE_BOOL = 'b';
|
||||
const TYPE_NULL = 's';
|
||||
const TYPE_INLINE = 'inlineStr';
|
||||
const TYPE_ERROR = 'e';
|
||||
|
||||
/**
|
||||
* List of error codes
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private static $_errorCodes = array('#NULL!' => 0, '#DIV/0!' => 1, '#VALUE!' => 2, '#REF!' => 3, '#NAME?' => 4, '#NUM!' => 5, '#N/A' => 6);
|
||||
|
||||
/**
|
||||
* Get list of error codes
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public static function getErrorCodes() {
|
||||
return self::$_errorCodes;
|
||||
}
|
||||
|
||||
/**
|
||||
* DataType for value
|
||||
*
|
||||
* @deprecated Replaced by PHPExcel_Cell_IValueBinder infrastructure
|
||||
* @param mixed $pValue
|
||||
* @return int
|
||||
*/
|
||||
public static function dataTypeForValue($pValue = null) {
|
||||
return PHPExcel_Cell_DefaultValueBinder::dataTypeForValue($pValue);
|
||||
}
|
||||
}
|
||||
500
include/PHPExcel/PHPExcel/Cell/DataValidation.php
Executable file
500
include/PHPExcel/PHPExcel/Cell/DataValidation.php
Executable file
@@ -0,0 +1,500 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell_DataValidation
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Cell_DataValidation
|
||||
{
|
||||
/* Data validation types */
|
||||
const TYPE_NONE = 'none';
|
||||
const TYPE_CUSTOM = 'custom';
|
||||
const TYPE_DATE = 'date';
|
||||
const TYPE_DECIMAL = 'decimal';
|
||||
const TYPE_LIST = 'list';
|
||||
const TYPE_TEXTLENGTH = 'textLength';
|
||||
const TYPE_TIME = 'time';
|
||||
const TYPE_WHOLE = 'whole';
|
||||
|
||||
/* Data validation error styles */
|
||||
const STYLE_STOP = 'stop';
|
||||
const STYLE_WARNING = 'warning';
|
||||
const STYLE_INFORMATION = 'information';
|
||||
|
||||
/* Data validation operators */
|
||||
const OPERATOR_BETWEEN = 'between';
|
||||
const OPERATOR_EQUAL = 'equal';
|
||||
const OPERATOR_GREATERTHAN = 'greaterThan';
|
||||
const OPERATOR_GREATERTHANOREQUAL = 'greaterThanOrEqual';
|
||||
const OPERATOR_LESSTHAN = 'lessThan';
|
||||
const OPERATOR_LESSTHANOREQUAL = 'lessThanOrEqual';
|
||||
const OPERATOR_NOTBETWEEN = 'notBetween';
|
||||
const OPERATOR_NOTEQUAL = 'notEqual';
|
||||
|
||||
/**
|
||||
* Formula 1
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_formula1;
|
||||
|
||||
/**
|
||||
* Formula 2
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_formula2;
|
||||
|
||||
/**
|
||||
* Type
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_type = PHPExcel_Cell_DataValidation::TYPE_NONE;
|
||||
|
||||
/**
|
||||
* Error style
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP;
|
||||
|
||||
/**
|
||||
* Operator
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_operator;
|
||||
|
||||
/**
|
||||
* Allow Blank
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_allowBlank;
|
||||
|
||||
/**
|
||||
* Show DropDown
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_showDropDown;
|
||||
|
||||
/**
|
||||
* Show InputMessage
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_showInputMessage;
|
||||
|
||||
/**
|
||||
* Show ErrorMessage
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_showErrorMessage;
|
||||
|
||||
/**
|
||||
* Error title
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_errorTitle;
|
||||
|
||||
/**
|
||||
* Error
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_error;
|
||||
|
||||
/**
|
||||
* Prompt title
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_promptTitle;
|
||||
|
||||
/**
|
||||
* Prompt
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_prompt;
|
||||
|
||||
/**
|
||||
* Parent cell
|
||||
*
|
||||
* @var PHPExcel_Cell
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Cell_DataValidation
|
||||
*
|
||||
* @param PHPExcel_Cell $pCell Parent cell
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct(PHPExcel_Cell $pCell = null)
|
||||
{
|
||||
// Initialise member variables
|
||||
$this->_formula1 = '';
|
||||
$this->_formula2 = '';
|
||||
$this->_type = PHPExcel_Cell_DataValidation::TYPE_NONE;
|
||||
$this->_errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP;
|
||||
$this->_operator = '';
|
||||
$this->_allowBlank = false;
|
||||
$this->_showDropDown = false;
|
||||
$this->_showInputMessage = false;
|
||||
$this->_showErrorMessage = false;
|
||||
$this->_errorTitle = '';
|
||||
$this->_error = '';
|
||||
$this->_promptTitle = '';
|
||||
$this->_prompt = '';
|
||||
|
||||
// Set cell
|
||||
$this->_parent = $pCell;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Formula 1
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getFormula1() {
|
||||
return $this->_formula1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Formula 1
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setFormula1($value = '') {
|
||||
$this->_formula1 = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Formula 2
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getFormula2() {
|
||||
return $this->_formula2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Formula 2
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setFormula2($value = '') {
|
||||
$this->_formula2 = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Type
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getType() {
|
||||
return $this->_type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Type
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setType($value = PHPExcel_Cell_DataValidation::TYPE_NONE) {
|
||||
$this->_type = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Error style
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getErrorStyle() {
|
||||
return $this->_errorStyle;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Error style
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setErrorStyle($value = PHPExcel_Cell_DataValidation::STYLE_STOP) {
|
||||
$this->_errorStyle = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Operator
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getOperator() {
|
||||
return $this->_operator;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Operator
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setOperator($value = '') {
|
||||
$this->_operator = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Allow Blank
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getAllowBlank() {
|
||||
return $this->_allowBlank;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Allow Blank
|
||||
*
|
||||
* @param boolean $value
|
||||
*/
|
||||
public function setAllowBlank($value = false) {
|
||||
$this->_allowBlank = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Show DropDown
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getShowDropDown() {
|
||||
return $this->_showDropDown;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Show DropDown
|
||||
*
|
||||
* @param boolean $value
|
||||
*/
|
||||
public function setShowDropDown($value = false) {
|
||||
$this->_showDropDown = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Show InputMessage
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getShowInputMessage() {
|
||||
return $this->_showInputMessage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Show InputMessage
|
||||
*
|
||||
* @param boolean $value
|
||||
*/
|
||||
public function setShowInputMessage($value = false) {
|
||||
$this->_showInputMessage = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Show ErrorMessage
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getShowErrorMessage() {
|
||||
return $this->_showErrorMessage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Show ErrorMessage
|
||||
*
|
||||
* @param boolean $value
|
||||
*/
|
||||
public function setShowErrorMessage($value = false) {
|
||||
$this->_showErrorMessage = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Error title
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getErrorTitle() {
|
||||
return $this->_errorTitle;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Error title
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setErrorTitle($value = '') {
|
||||
$this->_errorTitle = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Error
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getError() {
|
||||
return $this->_error;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Error
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setError($value = '') {
|
||||
$this->_error = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Prompt title
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getPromptTitle() {
|
||||
return $this->_promptTitle;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Prompt title
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setPromptTitle($value = '') {
|
||||
$this->_promptTitle = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Prompt
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getPrompt() {
|
||||
return $this->_prompt;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Prompt
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setPrompt($value = '') {
|
||||
$this->_prompt = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parent
|
||||
*
|
||||
* @return PHPExcel_Cell
|
||||
*/
|
||||
public function getParent() {
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Parent
|
||||
*
|
||||
* @param PHPExcel_Cell $value
|
||||
*/
|
||||
public function setParent($value = null) {
|
||||
$this->_parent = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode() {
|
||||
return md5(
|
||||
$this->_formula1
|
||||
. $this->_formula2
|
||||
. $this->_type = PHPExcel_Cell_DataValidation::TYPE_NONE
|
||||
. $this->_errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP
|
||||
. $this->_operator
|
||||
. ($this->_allowBlank ? 't' : 'f')
|
||||
. ($this->_showDropDown ? 't' : 'f')
|
||||
. ($this->_showInputMessage ? 't' : 'f')
|
||||
. ($this->_showErrorMessage ? 't' : 'f')
|
||||
. $this->_errorTitle
|
||||
. $this->_error
|
||||
. $this->_promptTitle
|
||||
. $this->_prompt
|
||||
. $this->_parent->getCoordinate()
|
||||
. __CLASS__
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
<complexType name="CT_DataValidation">
|
||||
<sequence>
|
||||
<element name="formula1" type="ST_Formula" minOccurs="0" maxOccurs="1"/>
|
||||
<element name="formula2" type="ST_Formula" minOccurs="0" maxOccurs="1"/>
|
||||
</sequence>
|
||||
<attribute name="type" type="ST_DataValidationType" use="optional" default="none"/>
|
||||
<attribute name="errorStyle" type="ST_DataValidationErrorStyle" use="optional" default="stop"/>
|
||||
<attribute name="imeMode" type="ST_DataValidationImeMode" use="optional" default="noControl"/>
|
||||
<attribute name="operator" type="ST_DataValidationOperator" use="optional" default="between"/>
|
||||
<attribute name="allowBlank" type="xsd:boolean" use="optional" default="false"/>
|
||||
<attribute name="showDropDown" type="xsd:boolean" use="optional" default="false"/>
|
||||
<attribute name="showInputMessage" type="xsd:boolean" use="optional" default="false"/>
|
||||
<attribute name="showErrorMessage" type="xsd:boolean" use="optional" default="false"/>
|
||||
<attribute name="errorTitle" type="ST_Xstring" use="optional"/>
|
||||
<attribute name="error" type="ST_Xstring" use="optional"/>
|
||||
<attribute name="promptTitle" type="ST_Xstring" use="optional"/>
|
||||
<attribute name="prompt" type="ST_Xstring" use="optional"/>
|
||||
<attribute name="sqref" type="ST_Sqref" use="required"/>
|
||||
</complexType>
|
||||
*/
|
||||
}
|
||||
90
include/PHPExcel/PHPExcel/Cell/DefaultValueBinder.php
Executable file
90
include/PHPExcel/PHPExcel/Cell/DefaultValueBinder.php
Executable file
@@ -0,0 +1,90 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_Cell_IValueBinder */
|
||||
require_once 'PHPExcel/Cell/IValueBinder.php';
|
||||
|
||||
/** PHPExcel_Cell_DataType */
|
||||
require_once 'PHPExcel/Cell/DataType.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell_DefaultValueBinder
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Cell_DefaultValueBinder implements PHPExcel_Cell_IValueBinder
|
||||
{
|
||||
/**
|
||||
* 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)
|
||||
{
|
||||
// Set value explicit
|
||||
$cell->setValueExplicit( $value, PHPExcel_Cell_DataType::dataTypeForValue($value) );
|
||||
|
||||
// Done!
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* DataType for value
|
||||
*
|
||||
* @param mixed $pValue
|
||||
* @return int
|
||||
*/
|
||||
public static function dataTypeForValue($pValue = null) {
|
||||
// Match the value against a few data types
|
||||
if (is_null($pValue)) {
|
||||
return PHPExcel_Cell_DataType::TYPE_NULL;
|
||||
} elseif ($pValue === '') {
|
||||
return PHPExcel_Cell_DataType::TYPE_STRING;
|
||||
} elseif ($pValue instanceof PHPExcel_RichText) {
|
||||
return PHPExcel_Cell_DataType::TYPE_STRING;
|
||||
} elseif ($pValue{0} === '=') {
|
||||
return PHPExcel_Cell_DataType::TYPE_FORMULA;
|
||||
} elseif (is_bool($pValue)) {
|
||||
return PHPExcel_Cell_DataType::TYPE_BOOL;
|
||||
} elseif (preg_match('/^\-?[0-9]*\.?[0-9]*$/', $pValue)) {
|
||||
return PHPExcel_Cell_DataType::TYPE_NUMERIC;
|
||||
} elseif (array_key_exists($pValue, PHPExcel_Cell_DataType::getErrorCodes())) {
|
||||
return PHPExcel_Cell_DataType::TYPE_ERROR;
|
||||
} else {
|
||||
return PHPExcel_Cell_DataType::TYPE_STRING;
|
||||
}
|
||||
}
|
||||
}
|
||||
153
include/PHPExcel/PHPExcel/Cell/Hyperlink.php
Executable file
153
include/PHPExcel/PHPExcel/Cell/Hyperlink.php
Executable file
@@ -0,0 +1,153 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell_Hyperlink
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Cell_Hyperlink
|
||||
{
|
||||
/**
|
||||
* Cell representing the hyperlink
|
||||
*
|
||||
* @var PHPExcel_Cell
|
||||
*/
|
||||
private $_cell;
|
||||
|
||||
/**
|
||||
* URL to link the cell to
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_url;
|
||||
|
||||
/**
|
||||
* Tooltip to display on the hyperlink
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_tooltip;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Cell_Hyperlink
|
||||
*
|
||||
* @param PHPExcel_Cell $pCell Parent cell
|
||||
* @param string $pUrl Url to link the cell to
|
||||
* @param string $pTooltip Tooltip to display on the hyperlink
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct(PHPExcel_Cell $pCell = null, $pUrl = '', $pTooltip = '')
|
||||
{
|
||||
// Initialise member variables
|
||||
$this->_url = $pUrl;
|
||||
$this->_tooltip = $pTooltip;
|
||||
|
||||
// Set cell
|
||||
$this->_parent = $pCell;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get URL
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getUrl() {
|
||||
return $this->_url;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set URL
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setUrl($value = '') {
|
||||
$this->_url = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get tooltip
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getTooltip() {
|
||||
return $this->_tooltip;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set tooltip
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setTooltip($value = '') {
|
||||
$this->_tooltip = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this hyperlink internal? (to another sheet)
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isInternal() {
|
||||
return strpos($this->_url, 'sheet://') !== false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parent
|
||||
*
|
||||
* @return PHPExcel_Cell
|
||||
*/
|
||||
public function getParent() {
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Parent
|
||||
*
|
||||
* @param PHPExcel_Cell $value
|
||||
*/
|
||||
public function setParent($value = null) {
|
||||
$this->_parent = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode() {
|
||||
return md5(
|
||||
$this->_url
|
||||
. $this->_tooltip
|
||||
. $this->_parent->getCoordinate()
|
||||
. __CLASS__
|
||||
);
|
||||
}
|
||||
}
|
||||
50
include/PHPExcel/PHPExcel/Cell/IValueBinder.php
Executable file
50
include/PHPExcel/PHPExcel/Cell/IValueBinder.php
Executable file
@@ -0,0 +1,50 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Cell_IValueBinder
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Cell
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
interface PHPExcel_Cell_IValueBinder
|
||||
{
|
||||
/**
|
||||
* 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);
|
||||
}
|
||||
315
include/PHPExcel/PHPExcel/Comment.php
Executable file
315
include/PHPExcel/PHPExcel/Comment.php
Executable file
@@ -0,0 +1,315 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_RichText */
|
||||
require_once 'PHPExcel/RichText.php';
|
||||
|
||||
/** PHPExcel_Style_Color */
|
||||
require_once 'PHPExcel/Style/Color.php';
|
||||
|
||||
/** PHPExcel_IComparable */
|
||||
require_once 'PHPExcel/IComparable.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Comment
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Comment implements PHPExcel_IComparable
|
||||
{
|
||||
/**
|
||||
* Author
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_author;
|
||||
|
||||
/**
|
||||
* Rich text comment
|
||||
*
|
||||
* @var PHPExcel_RichText
|
||||
*/
|
||||
private $_text;
|
||||
|
||||
/**
|
||||
* Comment width (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_width = '96pt';
|
||||
|
||||
/**
|
||||
* Left margin (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_marginLeft = '59.25pt';
|
||||
|
||||
/**
|
||||
* Top margin (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_marginTop = '1.5pt';
|
||||
|
||||
/**
|
||||
* Visible
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_visible = false;
|
||||
|
||||
/**
|
||||
* Comment height (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_height = '55.5pt';
|
||||
|
||||
/**
|
||||
* Comment fill color
|
||||
*
|
||||
* @var PHPExcel_Style_Color
|
||||
*/
|
||||
private $_fillColor;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Comment
|
||||
*
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
// Initialise variables
|
||||
$this->_author = 'Author';
|
||||
$this->_text = new PHPExcel_RichText();
|
||||
$this->_fillColor = new PHPExcel_Style_Color('FFFFFFE1');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Author
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getAuthor() {
|
||||
return $this->_author;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Author
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setAuthor($pValue = '') {
|
||||
$this->_author = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Rich text comment
|
||||
*
|
||||
* @return PHPExcel_RichText
|
||||
*/
|
||||
public function getText() {
|
||||
return $this->_text;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Rich text comment
|
||||
*
|
||||
* @param PHPExcel_RichText $pValue
|
||||
*/
|
||||
public function setText(PHPExcel_RichText $pValue) {
|
||||
$this->_text = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get comment width (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getWidth() {
|
||||
return $this->_width;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set comment width (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setWidth($value = '96pt') {
|
||||
$this->_width = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get comment height (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getHeight() {
|
||||
return $this->_height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set comment height (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setHeight($value = '55.5pt') {
|
||||
$this->_height = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get left margin (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getMarginLeft() {
|
||||
return $this->_marginLeft;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set left margin (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setMarginLeft($value = '59.25pt') {
|
||||
$this->_marginLeft = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get top margin (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getMarginTop() {
|
||||
return $this->_marginTop;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set top margin (CSS style, i.e. XXpx or YYpt)
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setMarginTop($value = '1.5pt') {
|
||||
$this->_marginTop = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the comment visible by default?
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getVisible() {
|
||||
return $this->_visible;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set comment default visibility
|
||||
*
|
||||
* @param boolean $value
|
||||
*/
|
||||
public function setVisible($value = false) {
|
||||
$this->_visible = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get fill color
|
||||
*
|
||||
* @return PHPExcel_Style_Color
|
||||
*/
|
||||
public function getFillColor() {
|
||||
return $this->_fillColor;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode() {
|
||||
return md5(
|
||||
$this->_author
|
||||
. $this->_text->getHashCode()
|
||||
. $this->_width
|
||||
. $this->_height
|
||||
. $this->_marginLeft
|
||||
. $this->_marginTop
|
||||
. ($this->_visible ? 1 : 0)
|
||||
. $this->_fillColor->getHashCode()
|
||||
. __CLASS__
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Hash index
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_hashIndex;
|
||||
|
||||
/**
|
||||
* Get hash index
|
||||
*
|
||||
* Note that this index may vary during script execution! Only reliable moment is
|
||||
* while doing a write of a workbook and when changes are not allowed.
|
||||
*
|
||||
* @return string Hash index
|
||||
*/
|
||||
public function getHashIndex() {
|
||||
return $this->_hashIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set hash index
|
||||
*
|
||||
* Note that this index may vary during script execution! Only reliable moment is
|
||||
* while doing a write of a workbook and when changes are not allowed.
|
||||
*
|
||||
* @param string $value Hash index
|
||||
*/
|
||||
public function setHashIndex($value) {
|
||||
$this->_hashIndex = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
299
include/PHPExcel/PHPExcel/DocumentProperties.php
Executable file
299
include/PHPExcel/PHPExcel/DocumentProperties.php
Executable file
@@ -0,0 +1,299 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_DocumentProperties
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_DocumentProperties
|
||||
{
|
||||
/**
|
||||
* Creator
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_creator;
|
||||
|
||||
/**
|
||||
* LastModifiedBy
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_lastModifiedBy;
|
||||
|
||||
/**
|
||||
* Created
|
||||
*
|
||||
* @var datetime
|
||||
*/
|
||||
private $_created;
|
||||
|
||||
/**
|
||||
* Modified
|
||||
*
|
||||
* @var datetime
|
||||
*/
|
||||
private $_modified;
|
||||
|
||||
/**
|
||||
* Title
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_title;
|
||||
|
||||
/**
|
||||
* Description
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_description;
|
||||
|
||||
/**
|
||||
* Subject
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_subject;
|
||||
|
||||
/**
|
||||
* Keywords
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_keywords;
|
||||
|
||||
/**
|
||||
* Category
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_category;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_DocumentProperties
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
// Initialise values
|
||||
$this->_creator = 'Unknown Creator';
|
||||
$this->_lastModifiedBy = $this->_creator;
|
||||
$this->_created = time();
|
||||
$this->_modified = time();
|
||||
$this->_title = "Untitled Spreadsheet";
|
||||
$this->_subject = '';
|
||||
$this->_description = '';
|
||||
$this->_keywords = '';
|
||||
$this->_category = '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Creator
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getCreator() {
|
||||
return $this->_creator;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Creator
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setCreator($pValue = '') {
|
||||
$this->_creator = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Last Modified By
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getLastModifiedBy() {
|
||||
return $this->_lastModifiedBy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Last Modified By
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setLastModifiedBy($pValue = '') {
|
||||
$this->_lastModifiedBy = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Created
|
||||
*
|
||||
* @return datetime
|
||||
*/
|
||||
public function getCreated() {
|
||||
return $this->_created;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Created
|
||||
*
|
||||
* @param datetime $pValue
|
||||
*/
|
||||
public function setCreated($pValue = null) {
|
||||
if (is_null($pValue)) {
|
||||
$pValue = time();
|
||||
}
|
||||
$this->_created = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Modified
|
||||
*
|
||||
* @return datetime
|
||||
*/
|
||||
public function getModified() {
|
||||
return $this->_modified;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Modified
|
||||
*
|
||||
* @param datetime $pValue
|
||||
*/
|
||||
public function setModified($pValue = null) {
|
||||
if (is_null($pValue)) {
|
||||
$pValue = time();
|
||||
}
|
||||
$this->_modified = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Title
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getTitle() {
|
||||
return $this->_title;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Title
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setTitle($pValue = '') {
|
||||
$this->_title = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Description
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getDescription() {
|
||||
return $this->_description;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Description
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setDescription($pValue = '') {
|
||||
$this->_description = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Subject
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getSubject() {
|
||||
return $this->_subject;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Subject
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setSubject($pValue = '') {
|
||||
$this->_subject = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Keywords
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getKeywords() {
|
||||
return $this->_keywords;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Keywords
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setKeywords($pValue = '') {
|
||||
$this->_keywords = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Category
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getCategory() {
|
||||
return $this->_category;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Category
|
||||
*
|
||||
* @param string $pValue
|
||||
*/
|
||||
public function setCategory($pValue = '') {
|
||||
$this->_category = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
212
include/PHPExcel/PHPExcel/DocumentSecurity.php
Executable file
212
include/PHPExcel/PHPExcel/DocumentSecurity.php
Executable file
@@ -0,0 +1,212 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Shared_PasswordHasher */
|
||||
require_once 'PHPExcel/Shared/PasswordHasher.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_DocumentSecurity
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_DocumentSecurity
|
||||
{
|
||||
/**
|
||||
* LockRevision
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_lockRevision;
|
||||
|
||||
/**
|
||||
* LockStructure
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_lockStructure;
|
||||
|
||||
/**
|
||||
* LockWindows
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_lockWindows;
|
||||
|
||||
/**
|
||||
* RevisionsPassword
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_revisionsPassword;
|
||||
|
||||
/**
|
||||
* WorkbookPassword
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_workbookPassword;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_DocumentSecurity
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
// Initialise values
|
||||
$this->_lockRevision = false;
|
||||
$this->_lockStructure = false;
|
||||
$this->_lockWindows = false;
|
||||
$this->_revisionsPassword = '';
|
||||
$this->_workbookPassword = '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Is some sort of dcument security enabled?
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
function isSecurityEnabled() {
|
||||
return $this->_lockRevision ||
|
||||
$this->_lockStructure ||
|
||||
$this->_lockWindows;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get LockRevision
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
function getLockRevision() {
|
||||
return $this->_lockRevision;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set LockRevision
|
||||
*
|
||||
* @param boolean $pValue
|
||||
*/
|
||||
function setLockRevision($pValue = false) {
|
||||
$this->_lockRevision = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get LockStructure
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
function getLockStructure() {
|
||||
return $this->_lockStructure;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set LockStructure
|
||||
*
|
||||
* @param boolean $pValue
|
||||
*/
|
||||
function setLockStructure($pValue = false) {
|
||||
$this->_lockStructure = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get LockWindows
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
function getLockWindows() {
|
||||
return $this->_lockWindows;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set LockWindows
|
||||
*
|
||||
* @param boolean $pValue
|
||||
*/
|
||||
function setLockWindows($pValue = false) {
|
||||
$this->_lockWindows = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get RevisionsPassword (hashed)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
function getRevisionsPassword() {
|
||||
return $this->_revisionsPassword;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set RevisionsPassword
|
||||
*
|
||||
* @param string $pValue
|
||||
* @param boolean $pAlreadyHashed If the password has already been hashed, set this to true
|
||||
*/
|
||||
function setRevisionsPassword($pValue = '', $pAlreadyHashed = false) {
|
||||
if (!$pAlreadyHashed) {
|
||||
$pValue = PHPExcel_Shared_PasswordHasher::hashPassword($pValue);
|
||||
}
|
||||
$this->_revisionsPassword = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get WorkbookPassword (hashed)
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
function getWorkbookPassword() {
|
||||
return $this->_workbookPassword;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set WorkbookPassword
|
||||
*
|
||||
* @param string $pValue
|
||||
* @param boolean $pAlreadyHashed If the password has already been hashed, set this to true
|
||||
*/
|
||||
function setWorkbookPassword($pValue = '', $pAlreadyHashed = false) {
|
||||
if (!$pAlreadyHashed) {
|
||||
$pValue = PHPExcel_Shared_PasswordHasher::hashPassword($pValue);
|
||||
}
|
||||
$this->_workbookPassword = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
209
include/PHPExcel/PHPExcel/HashTable.php
Executable file
209
include/PHPExcel/PHPExcel/HashTable.php
Executable file
@@ -0,0 +1,209 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_IComparable */
|
||||
require_once 'PHPExcel/IComparable.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_HashTable
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_HashTable
|
||||
{
|
||||
/**
|
||||
* HashTable elements
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public $_items = array();
|
||||
|
||||
/**
|
||||
* HashTable key map
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
public $_keyMap = array();
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_HashTable
|
||||
*
|
||||
* @param PHPExcel_IComparable[] $pSource Optional source array to create HashTable from
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct($pSource = null)
|
||||
{
|
||||
if (!is_null($pSource)) {
|
||||
// Create HashTable
|
||||
$this->addFromSource($pSource);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add HashTable items from source
|
||||
*
|
||||
* @param PHPExcel_IComparable[] $pSource Source array to create HashTable from
|
||||
* @throws Exception
|
||||
*/
|
||||
public function addFromSource($pSource = null) {
|
||||
// Check if an array was passed
|
||||
if ($pSource == null) {
|
||||
return;
|
||||
} else if (!is_array($pSource)) {
|
||||
throw new Exception('Invalid array parameter passed.');
|
||||
}
|
||||
|
||||
foreach ($pSource as $item) {
|
||||
$this->add($item);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add HashTable item
|
||||
*
|
||||
* @param PHPExcel_IComparable $pSource Item to add
|
||||
* @throws Exception
|
||||
*/
|
||||
public function add(PHPExcel_IComparable $pSource = null) {
|
||||
$hashCode = $pSource->getHashCode();
|
||||
if (!isset($this->_items[ $hashCode ])) {
|
||||
$this->_items[ $hashCode ] = $pSource;
|
||||
$index = count($this->_items) - 1;
|
||||
$this->_keyMap[ $index ] = $hashCode;
|
||||
$pSource->setHashIndex( $index );
|
||||
} else {
|
||||
$pSource->setHashIndex( $this->_items[ $hashCode ]->getHashIndex() );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove HashTable item
|
||||
*
|
||||
* @param PHPExcel_IComparable $pSource Item to remove
|
||||
* @throws Exception
|
||||
*/
|
||||
public function remove(PHPExcel_IComparable $pSource = null) {
|
||||
if (isset($this->_items[ $pSource->getHashCode() ])) {
|
||||
unset($this->_items[ $pSource->getHashCode() ]);
|
||||
|
||||
$deleteKey = -1;
|
||||
foreach ($this->_keyMap as $key => $value) {
|
||||
if ($deleteKey >= 0) {
|
||||
$this->_keyMap[$key - 1] = $value;
|
||||
}
|
||||
|
||||
if ($value == $pSource->getHashCode()) {
|
||||
$deleteKey = $key;
|
||||
}
|
||||
}
|
||||
unset($this->_keyMap[ count($this->_keyMap) - 1 ]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear HashTable
|
||||
*
|
||||
*/
|
||||
public function clear() {
|
||||
$this->_items = array();
|
||||
$this->_keyMap = array();
|
||||
}
|
||||
|
||||
/**
|
||||
* Count
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function count() {
|
||||
return count($this->_items);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get index for hash code
|
||||
*
|
||||
* @param string $pHashCode
|
||||
* @return int Index
|
||||
*/
|
||||
public function getIndexForHashCode($pHashCode = '') {
|
||||
return array_search($pHashCode, $this->_keyMap);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get by index
|
||||
*
|
||||
* @param int $pIndex
|
||||
* @return PHPExcel_IComparable
|
||||
*
|
||||
*/
|
||||
public function getByIndex($pIndex = 0) {
|
||||
if (isset($this->_keyMap[$pIndex])) {
|
||||
return $this->getByHashCode( $this->_keyMap[$pIndex] );
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get by hashcode
|
||||
*
|
||||
* @param string $pHashCode
|
||||
* @return PHPExcel_IComparable
|
||||
*
|
||||
*/
|
||||
public function getByHashCode($pHashCode = '') {
|
||||
if (isset($this->_items[$pHashCode])) {
|
||||
return $this->_items[$pHashCode];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* HashTable to array
|
||||
*
|
||||
* @return PHPExcel_IComparable[]
|
||||
*/
|
||||
public function toArray() {
|
||||
return $this->_items;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
62
include/PHPExcel/PHPExcel/IComparable.php
Executable file
62
include/PHPExcel/PHPExcel/IComparable.php
Executable file
@@ -0,0 +1,62 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_IComparable
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
interface PHPExcel_IComparable
|
||||
{
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode();
|
||||
|
||||
/**
|
||||
* Get hash index
|
||||
*
|
||||
* Note that this index may vary during script execution! Only reliable moment is
|
||||
* while doing a write of a workbook and when changes are not allowed.
|
||||
*
|
||||
* @return string Hash index
|
||||
*/
|
||||
public function getHashIndex();
|
||||
|
||||
/**
|
||||
* Set hash index
|
||||
*
|
||||
* Note that this index may vary during script execution! Only reliable moment is
|
||||
* while doing a write of a workbook and when changes are not allowed.
|
||||
*
|
||||
* @param string $value Hash index
|
||||
*/
|
||||
public function setHashIndex($value);
|
||||
}
|
||||
175
include/PHPExcel/PHPExcel/IOFactory.php
Executable file
175
include/PHPExcel/PHPExcel/IOFactory.php
Executable file
@@ -0,0 +1,175 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel */
|
||||
require_once 'PHPExcel.php';
|
||||
|
||||
/** PHPExcel_IWriter */
|
||||
require_once 'PHPExcel/Writer/IWriter.php';
|
||||
|
||||
/** PHPExcel_IReader */
|
||||
require_once 'PHPExcel/Reader/IReader.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_IOFactory
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_IOFactory
|
||||
{
|
||||
/**
|
||||
* Search locations
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private static $_searchLocations = array(
|
||||
array( 'type' => 'IWriter', 'path' => 'PHPExcel/Writer/{0}.php', 'class' => 'PHPExcel_Writer_{0}' ),
|
||||
array( 'type' => 'IReader', 'path' => 'PHPExcel/Reader/{0}.php', 'class' => 'PHPExcel_Reader_{0}' )
|
||||
);
|
||||
|
||||
/**
|
||||
* Private constructor for PHPExcel_IOFactory
|
||||
*/
|
||||
private function __construct() { }
|
||||
|
||||
/**
|
||||
* Get search locations
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public static function getSearchLocations() {
|
||||
return self::$_searchLocations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set search locations
|
||||
*
|
||||
* @param array $value
|
||||
* @throws Exception
|
||||
*/
|
||||
public static function setSearchLocations($value) {
|
||||
if (is_array($value)) {
|
||||
self::$_searchLocations = $value;
|
||||
} else {
|
||||
throw new Exception('Invalid parameter passed.');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add search location
|
||||
*
|
||||
* @param string $type Example: IWriter
|
||||
* @param string $location Example: PHPExcel/Writer/{0}.php
|
||||
* @param string $classname Example: PHPExcel_Writer_{0}
|
||||
*/
|
||||
public static function addSearchLocation($type = '', $location = '', $classname = '') {
|
||||
self::$_searchLocations[] = array( 'type' => $type, 'path' => $location, 'class' => $classname );
|
||||
}
|
||||
|
||||
/**
|
||||
* Create PHPExcel_Writer_IWriter
|
||||
*
|
||||
* @param PHPExcel $phpExcel
|
||||
* @param string $writerType Example: Excel2007
|
||||
* @return PHPExcel_Writer_IWriter
|
||||
*/
|
||||
public static function createWriter(PHPExcel $phpExcel, $writerType = '') {
|
||||
// Search type
|
||||
$searchType = 'IWriter';
|
||||
|
||||
// Include class
|
||||
foreach (self::$_searchLocations as $searchLocation) {
|
||||
if ($searchLocation['type'] == $searchType) {
|
||||
$className = str_replace('{0}', $writerType, $searchLocation['class']);
|
||||
$classFile = str_replace('{0}', $writerType, $searchLocation['path']);
|
||||
|
||||
if (!class_exists($className)) {
|
||||
self::requireFile($classFile);
|
||||
}
|
||||
|
||||
$instance = new $className($phpExcel);
|
||||
if (!is_null($instance)) {
|
||||
return $instance;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Nothing found...
|
||||
throw new Exception("No $searchType found for type $writerType");
|
||||
}
|
||||
|
||||
/**
|
||||
* Create PHPExcel_Reader_IReader
|
||||
*
|
||||
* @param string $readerType Example: Excel2007
|
||||
* @return PHPExcel_Reader_IReader
|
||||
*/
|
||||
public static function createReader($readerType = '') {
|
||||
// Search type
|
||||
$searchType = 'IReader';
|
||||
|
||||
// Include class
|
||||
foreach (self::$_searchLocations as $searchLocation) {
|
||||
if ($searchLocation['type'] == $searchType) {
|
||||
$className = str_replace('{0}', $readerType, $searchLocation['class']);
|
||||
$classFile = str_replace('{0}', $readerType, $searchLocation['path']);
|
||||
|
||||
if (!class_exists($className)) {
|
||||
self::requireFile($classFile);
|
||||
}
|
||||
|
||||
$instance = new $className();
|
||||
if (!is_null($instance)) {
|
||||
return $instance;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Nothing found...
|
||||
throw new Exception("No $searchType found for type $readerType");
|
||||
}
|
||||
|
||||
/**
|
||||
* Require_once file
|
||||
*
|
||||
* @param string $filename
|
||||
*/
|
||||
private static function requireFile($filename) {
|
||||
$includePath = get_include_path();
|
||||
$includeTokens = explode(PATH_SEPARATOR, $includePath);
|
||||
|
||||
foreach ($includeTokens as $includeToken) {
|
||||
if (file_exists($includeToken . '/' . $filename)) {
|
||||
require_once( $filename );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
214
include/PHPExcel/PHPExcel/NamedRange.php
Executable file
214
include/PHPExcel/PHPExcel/NamedRange.php
Executable file
@@ -0,0 +1,214 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel */
|
||||
require_once 'PHPExcel.php';
|
||||
|
||||
/** PHPExcel_Worksheet */
|
||||
require_once 'PHPExcel/Worksheet.php';
|
||||
|
||||
/** PHPExcel_ReferenceHelper */
|
||||
require_once 'PHPExcel/ReferenceHelper.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_NamedRange
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_NamedRange
|
||||
{
|
||||
/**
|
||||
* Range name
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_name;
|
||||
|
||||
/**
|
||||
* Worksheet on which the named range can be resolved
|
||||
*
|
||||
* @var PHPExcel_Worksheet
|
||||
*/
|
||||
private $_worksheet;
|
||||
|
||||
/**
|
||||
* Range of the referenced cells
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_range;
|
||||
|
||||
/**
|
||||
* Is the named range local? (i.e. can only be used on $this->_worksheet)
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
private $_localOnly;
|
||||
|
||||
/**
|
||||
* Create a new NamedRange
|
||||
*
|
||||
* @param string $pName
|
||||
* @param PHPExcel_Worksheet $pWorksheet
|
||||
* @param string $pRange
|
||||
* @param bool $pLocalOnly
|
||||
*/
|
||||
public function __construct($pName = null, PHPExcel_Worksheet $pWorksheet, $pRange = 'A1', $pLocalOnly = false)
|
||||
{
|
||||
// Validate data
|
||||
if (is_null($pName) || is_null($pWorksheet)|| is_null($pRange)) {
|
||||
throw new Exception('Parameters can not be null.');
|
||||
}
|
||||
|
||||
// Set local members
|
||||
$this->_name = $pName;
|
||||
$this->_worksheet = $pWorksheet;
|
||||
$this->_range = $pRange;
|
||||
$this->_localOnly = $pLocalOnly;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get name
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getName() {
|
||||
return $this->_name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set name
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setName($value = null) {
|
||||
if (!is_null($value)) {
|
||||
// Old title
|
||||
$oldTitle = $this->_name;
|
||||
|
||||
// Re-attach
|
||||
if (!is_null($this->_worksheet)) {
|
||||
$this->_worksheet->getParent()->removeNamedRange($this->_name);
|
||||
}
|
||||
$this->_name = $value;
|
||||
if (!is_null($this->_worksheet)) {
|
||||
$this->_worksheet->getParent()->addNamedRange($this);
|
||||
}
|
||||
|
||||
// New title
|
||||
$newTitle = $this->_name;
|
||||
PHPExcel_ReferenceHelper::getInstance()->updateNamedFormulas($this->_worksheet->getParent(), $oldTitle, $newTitle);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get worksheet
|
||||
*
|
||||
* @return PHPExcel_Worksheet
|
||||
*/
|
||||
public function getWorksheet() {
|
||||
return $this->_worksheet;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set worksheet
|
||||
*
|
||||
* @param PHPExcel_Worksheet $value
|
||||
*/
|
||||
public function setWorksheet(PHPExcel_Worksheet $value = null) {
|
||||
if (!is_null($value)) {
|
||||
$this->_worksheet = $value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get range
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getRange() {
|
||||
return $this->_range;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set range
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setRange($value = null) {
|
||||
if (!is_null($value)) {
|
||||
$this->_range = $value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get localOnly
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function getLocalOnly() {
|
||||
return $this->_localOnly;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set localOnly
|
||||
*
|
||||
* @param bool $value
|
||||
*/
|
||||
public function setLocalOnly($value = false) {
|
||||
$this->_localOnly = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve a named range to a regular cell range
|
||||
*
|
||||
* @param string $pNamedRange Named range
|
||||
* @param PHPExcel_Worksheet $pSheet Worksheet
|
||||
* @return PHPExcel_NamedRange
|
||||
*/
|
||||
public static function resolveRange($pNamedRange = '', PHPExcel_Worksheet $pSheet) {
|
||||
return $pSheet->getParent()->getNamedRange($pNamedRange);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
231
include/PHPExcel/PHPExcel/Reader/CSV.php
Executable file
231
include/PHPExcel/PHPExcel/Reader/CSV.php
Executable file
@@ -0,0 +1,231 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel */
|
||||
require_once 'PHPExcel.php';
|
||||
|
||||
/** PHPExcel_Reader_IReader */
|
||||
require_once 'PHPExcel/Reader/IReader.php';
|
||||
|
||||
/** PHPExcel_Worksheet */
|
||||
require_once 'PHPExcel/Worksheet.php';
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Reader_CSV
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Reader_CSV implements PHPExcel_Reader_IReader
|
||||
{
|
||||
/**
|
||||
* Delimiter
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_delimiter;
|
||||
|
||||
/**
|
||||
* Enclosure
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_enclosure;
|
||||
|
||||
/**
|
||||
* Line ending
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_lineEnding;
|
||||
|
||||
/**
|
||||
* Sheet index to read
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_sheetIndex;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Reader_CSV
|
||||
*/
|
||||
public function __construct() {
|
||||
$this->_delimiter = ',';
|
||||
$this->_enclosure = '"';
|
||||
$this->_lineEnding = PHP_EOL;
|
||||
$this->_sheetIndex = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads PHPExcel from file
|
||||
*
|
||||
* @param string $pFilename
|
||||
* @throws Exception
|
||||
*/
|
||||
public function load($pFilename)
|
||||
{
|
||||
// Create new PHPExcel
|
||||
$objPHPExcel = new PHPExcel();
|
||||
|
||||
// Load into this instance
|
||||
return $this->loadIntoExisting($pFilename, $objPHPExcel);
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads PHPExcel from file into PHPExcel instance
|
||||
*
|
||||
* @param string $pFilename
|
||||
* @param PHPExcel $objPHPExcel
|
||||
* @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.");
|
||||
}
|
||||
|
||||
// Loop trough 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) {
|
||||
if ($rowData[$i] != '') {
|
||||
// Unescape enclosures
|
||||
$rowData[$i] = str_replace("\\" . $this->_enclosure, $this->_enclosure, $rowData[$i]);
|
||||
$rowData[$i] = str_replace($this->_enclosure . $this->_enclosure, $this->_enclosure, $rowData[$i]);
|
||||
|
||||
// Set cell value
|
||||
$objPHPExcel->getActiveSheet()->setCellValue(
|
||||
PHPExcel_Cell::stringFromColumnIndex($i) . $currentRow, $rowData[$i]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Close file
|
||||
fclose($fileHandle);
|
||||
|
||||
// Return
|
||||
return $objPHPExcel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get delimiter
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getDelimiter() {
|
||||
return $this->_delimiter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set delimiter
|
||||
*
|
||||
* @param string $pValue Delimiter, defaults to ,
|
||||
*/
|
||||
public function setDelimiter($pValue = ',') {
|
||||
$this->_delimiter = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get enclosure
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getEnclosure() {
|
||||
return $this->_enclosure;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set enclosure
|
||||
*
|
||||
* @param string $pValue Enclosure, defaults to "
|
||||
*/
|
||||
public function setEnclosure($pValue = '"') {
|
||||
if ($pValue == '') {
|
||||
$pValue = '"';
|
||||
}
|
||||
$this->_enclosure = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get line ending
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getLineEnding() {
|
||||
return $this->_lineEnding;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set line ending
|
||||
*
|
||||
* @param string $pValue Line ending, defaults to OS line ending (PHP_EOL)
|
||||
*/
|
||||
public function setLineEnding($pValue = PHP_EOL) {
|
||||
$this->_lineEnding = $pValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get sheet index
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getSheetIndex() {
|
||||
return $this->_sheetIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set sheet index
|
||||
*
|
||||
* @param int $pValue Sheet index
|
||||
*/
|
||||
public function setSheetIndex($pValue = 0) {
|
||||
$this->_sheetIndex = $pValue;
|
||||
}
|
||||
}
|
||||
53
include/PHPExcel/PHPExcel/Reader/DefaultReadFilter.php
Executable file
53
include/PHPExcel/PHPExcel/Reader/DefaultReadFilter.php
Executable file
@@ -0,0 +1,53 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Reader_IReadFilter */
|
||||
require_once 'PHPExcel/Reader/IReadFilter.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Reader_DefaultReadFilter
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Reader_DefaultReadFilter implements PHPExcel_Reader_IReadFilter
|
||||
{
|
||||
/**
|
||||
* Should this cell be read?
|
||||
*
|
||||
* @param $column String column index
|
||||
* @param $row Row index
|
||||
* @param $worksheetName Optional worksheet name
|
||||
* @return boolean
|
||||
*/
|
||||
public function readCell($column, $row, $worksheetName = '') {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
1381
include/PHPExcel/PHPExcel/Reader/Excel2007.php
Executable file
1381
include/PHPExcel/PHPExcel/Reader/Excel2007.php
Executable file
File diff suppressed because it is too large
Load Diff
4897
include/PHPExcel/PHPExcel/Reader/Excel5.php
Executable file
4897
include/PHPExcel/PHPExcel/Reader/Excel5.php
Executable file
File diff suppressed because it is too large
Load Diff
701
include/PHPExcel/PHPExcel/Reader/Excel5/Escher.php
Executable file
701
include/PHPExcel/PHPExcel/Reader/Excel5/Escher.php
Executable file
@@ -0,0 +1,701 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader_Excel5
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DggContainer */
|
||||
require_once 'PHPExcel/Shared/Escher/DggContainer.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DggContainer_BstoreContainer */
|
||||
require_once 'PHPExcel/Shared/Escher/DggContainer/BstoreContainer.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE */
|
||||
require_once 'PHPExcel/Shared/Escher/DggContainer/BstoreContainer/BSE.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip */
|
||||
require_once 'PHPExcel/Shared/Escher/DggContainer/BstoreContainer/BSE/Blip.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DgContainer */
|
||||
require_once 'PHPExcel/Shared/Escher/DgContainer.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DgContainer_SpgrContainer */
|
||||
require_once 'PHPExcel/Shared/Escher/DgContainer/SpgrContainer.php';
|
||||
|
||||
/** PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer */
|
||||
require_once 'PHPExcel/Shared/Escher/DgContainer/SpgrContainer/SpContainer.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_Reader_Excel5_Escher
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader_Excel5
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Reader_Excel5_Escher
|
||||
{
|
||||
const DGGCONTAINER = 0xF000;
|
||||
const BSTORECONTAINER = 0xF001;
|
||||
const DGCONTAINER = 0xF002;
|
||||
const SPGRCONTAINER = 0xF003;
|
||||
const SPCONTAINER = 0xF004;
|
||||
const DGG = 0xF006;
|
||||
const BSE = 0xF007;
|
||||
const DG = 0xF008;
|
||||
const SPGR = 0xF009;
|
||||
const SP = 0xF00A;
|
||||
const OPT = 0xF00B;
|
||||
const CLIENTTEXTBOX = 0xF00D;
|
||||
const CLIENTANCHOR = 0xF010;
|
||||
const CLIENTDATA = 0xF011;
|
||||
const BLIPJPEG = 0xF01D;
|
||||
const BLIPPNG = 0xF01E;
|
||||
const SPLITMENUCOLORS = 0xF11E;
|
||||
const TERTIARYOPT = 0xF122;
|
||||
|
||||
/**
|
||||
* Escher stream data (binary)
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_data;
|
||||
|
||||
/**
|
||||
* Size in bytes of the Escher stream data
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_dataSize;
|
||||
|
||||
/**
|
||||
* Current position of stream pointer in Escher stream data
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_pos;
|
||||
|
||||
/**
|
||||
* The object to be returned by the reader. Modified during load.
|
||||
*
|
||||
* @var mixed
|
||||
*/
|
||||
private $_object;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Reader_Excel5_Escher instance
|
||||
*
|
||||
* @param mixed $object
|
||||
*/
|
||||
public function __construct($object)
|
||||
{
|
||||
$this->_object = $object;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load Escher stream data. May be a partial Escher stream.
|
||||
*
|
||||
* @param string $data
|
||||
*/
|
||||
public function load($data)
|
||||
{
|
||||
$this->_data = $data;
|
||||
|
||||
// total byte size of Excel data (workbook global substream + sheet substreams)
|
||||
$this->_dataSize = strlen($this->_data);
|
||||
|
||||
$this->_pos = 0;
|
||||
|
||||
// Parse Escher stream
|
||||
while ($this->_pos < $this->_dataSize) {
|
||||
|
||||
|
||||
// offset: 2; size: 2: Record Type
|
||||
$fbt = $this->_GetInt2d($this->_data, $this->_pos + 2);
|
||||
|
||||
switch ($fbt) {
|
||||
case self::DGGCONTAINER: $this->_readDggContainer(); break;
|
||||
case self::DGG: $this->_readDgg(); break;
|
||||
case self::BSTORECONTAINER: $this->_readBstoreContainer(); break;
|
||||
case self::BSE: $this->_readBSE(); break;
|
||||
case self::BLIPJPEG: $this->_readBlipJPEG(); break;
|
||||
case self::BLIPPNG: $this->_readBlipPNG(); break;
|
||||
case self::OPT: $this->_readOPT(); break;
|
||||
case self::TERTIARYOPT: $this->_readTertiaryOPT(); break;
|
||||
case self::SPLITMENUCOLORS: $this->_readSplitMenuColors(); break;
|
||||
case self::DGCONTAINER: $this->_readDgContainer(); break;
|
||||
case self::DG: $this->_readDg(); break;
|
||||
case self::SPGRCONTAINER: $this->_readSpgrContainer(); break;
|
||||
case self::SPCONTAINER: $this->_readSpContainer(); break;
|
||||
case self::SPGR: $this->_readSpgr(); break;
|
||||
case self::SP: $this->_readSp(); break;
|
||||
case self::CLIENTTEXTBOX: $this->_readClientTextbox(); break;
|
||||
case self::CLIENTANCHOR: $this->_readClientAnchor(); break;
|
||||
case self::CLIENTDATA: $this->_readClientData(); break;
|
||||
default: $this->_readDefault(); break;
|
||||
}
|
||||
}
|
||||
|
||||
return $this->_object;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a generic record
|
||||
*/
|
||||
private function _readDefault()
|
||||
{
|
||||
// offset 0; size: 2; recVer and recInstance
|
||||
$verInstance = $this->_GetInt2d($this->_data, $this->_pos);
|
||||
|
||||
// offset: 2; size: 2: Record Type
|
||||
$fbt = $this->_GetInt2d($this->_data, $this->_pos + 2);
|
||||
|
||||
// bit: 0-3; mask: 0x000F; recVer
|
||||
$recVer = (0x000F & $verInstance) >> 0;
|
||||
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read DggContainer record (Drawing Group Container)
|
||||
*/
|
||||
private function _readDggContainer()
|
||||
{
|
||||
$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;
|
||||
|
||||
// record is a container, read contents
|
||||
$dggContainer = new PHPExcel_Shared_Escher_DggContainer();
|
||||
$this->_object->setDggContainer($dggContainer);
|
||||
$reader = new PHPExcel_Reader_Excel5_Escher($dggContainer);
|
||||
$reader->load($recordData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Dgg record (Drawing Group)
|
||||
*/
|
||||
private function _readDgg()
|
||||
{
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read BstoreContainer record (Blip Store Container)
|
||||
*/
|
||||
private function _readBstoreContainer()
|
||||
{
|
||||
$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;
|
||||
|
||||
// record is a container, read contents
|
||||
$bstoreContainer = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer();
|
||||
$this->_object->setBstoreContainer($bstoreContainer);
|
||||
$reader = new PHPExcel_Reader_Excel5_Escher($bstoreContainer);
|
||||
$reader->load($recordData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read BSE record
|
||||
*/
|
||||
private function _readBSE()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
|
||||
// add BSE to BstoreContainer
|
||||
$BSE = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE();
|
||||
$this->_object->addBSE($BSE);
|
||||
|
||||
$BSE->setBLIPType($recInstance);
|
||||
|
||||
// offset: 0; size: 1; btWin32 (MSOBLIPTYPE)
|
||||
$btWin32 = ord($recordData[0]);
|
||||
|
||||
// offset: 1; size: 1; btWin32 (MSOBLIPTYPE)
|
||||
$btMacOS = ord($recordData[1]);
|
||||
|
||||
// offset: 2; size: 16; MD4 digest
|
||||
$rgbUid = substr($recordData, 2, 16);
|
||||
|
||||
// offset: 18; size: 2; tag
|
||||
$tag = $this->_GetInt2d($recordData, 18);
|
||||
|
||||
// offset: 20; size: 4; size of BLIP in bytes
|
||||
$size = $this->_GetInt4d($recordData, 20);
|
||||
|
||||
// offset: 24; size: 4; number of references to this BLIP
|
||||
$cRef = $this->_GetInt4d($recordData, 24);
|
||||
|
||||
// offset: 28; size: 4; MSOFO file offset
|
||||
$foDelay = $this->_GetInt4d($recordData, 28);
|
||||
|
||||
// offset: 32; size: 1; unused1
|
||||
$unused1 = ord($recordData{32});
|
||||
|
||||
// offset: 33; size: 1; size of nameData in bytes (including null terminator)
|
||||
$cbName = ord($recordData{33});
|
||||
|
||||
// offset: 34; size: 1; unused2
|
||||
$unused2 = ord($recordData{34});
|
||||
|
||||
// offset: 35; size: 1; unused3
|
||||
$unused3 = ord($recordData{35});
|
||||
|
||||
// offset: 36; size: $cbName; nameData
|
||||
$nameData = substr($recordData, 36, $cbName);
|
||||
|
||||
// offset: 36 + $cbName, size: var; the BLIP data
|
||||
$blipData = substr($recordData, 36 + $cbName);
|
||||
|
||||
// record is a container, read contents
|
||||
$reader = new PHPExcel_Reader_Excel5_Escher($BSE);
|
||||
$reader->load($blipData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read BlipJPEG record. Holds raw JPEG image data
|
||||
*/
|
||||
private function _readBlipJPEG()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
|
||||
$pos = 0;
|
||||
|
||||
// offset: 0; size: 16; rgbUid1 (MD4 digest of)
|
||||
$rgbUid1 = substr($recordData, 0, 16);
|
||||
$pos += 16;
|
||||
|
||||
// offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3
|
||||
if (in_array($recInstance, array(0x046B, 0x06E3))) {
|
||||
$rgbUid2 = substr($recordData, 16, 16);
|
||||
$pos += 16;
|
||||
}
|
||||
|
||||
// offset: var; size: 1; tag
|
||||
$tag = ord($recordData{$pos});
|
||||
$pos += 1;
|
||||
|
||||
// offset: var; size: var; the raw image data
|
||||
$data = substr($recordData, $pos);
|
||||
|
||||
$blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip();
|
||||
$blip->setData($data);
|
||||
|
||||
$this->_object->setBlip($blip);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read BlipPNG record. Holds raw PNG image data
|
||||
*/
|
||||
private function _readBlipPNG()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
|
||||
$pos = 0;
|
||||
|
||||
// offset: 0; size: 16; rgbUid1 (MD4 digest of)
|
||||
$rgbUid1 = substr($recordData, 0, 16);
|
||||
$pos += 16;
|
||||
|
||||
// offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3
|
||||
if ($recInstance == 0x06E1) {
|
||||
$rgbUid2 = substr($recordData, 16, 16);
|
||||
$pos += 16;
|
||||
}
|
||||
|
||||
// offset: var; size: 1; tag
|
||||
$tag = ord($recordData{$pos});
|
||||
$pos += 1;
|
||||
|
||||
// offset: var; size: var; the raw image data
|
||||
$data = substr($recordData, $pos);
|
||||
|
||||
$blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip();
|
||||
$blip->setData($data);
|
||||
|
||||
$this->_object->setBlip($blip);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read OPT record. This record may occur within DggContainer record or SpContainer
|
||||
*/
|
||||
private function _readOPT()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
|
||||
$this->_readOfficeArtRGFOPTE($recordData, $recInstance);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read TertiaryOPT record
|
||||
*/
|
||||
private function _readTertiaryOPT()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read SplitMenuColors record
|
||||
*/
|
||||
private function _readSplitMenuColors()
|
||||
{
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read DgContainer record (Drawing Container)
|
||||
*/
|
||||
private function _readDgContainer()
|
||||
{
|
||||
$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;
|
||||
|
||||
// record is a container, read contents
|
||||
$dgContainer = new PHPExcel_Shared_Escher_DgContainer();
|
||||
$this->_object->setDgContainer($dgContainer);
|
||||
$reader = new PHPExcel_Reader_Excel5_Escher($dgContainer);
|
||||
$escher = $reader->load($recordData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Dg record (Drawing)
|
||||
*/
|
||||
private function _readDg()
|
||||
{
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read SpgrContainer record (Shape Group Container)
|
||||
*/
|
||||
private function _readSpgrContainer()
|
||||
{
|
||||
// context is either context DgContainer or SpgrContainer
|
||||
|
||||
$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;
|
||||
|
||||
// record is a container, read contents
|
||||
$spgrContainer = new PHPExcel_Shared_Escher_DgContainer_SpgrContainer();
|
||||
|
||||
if ($this->_object instanceof PHPExcel_Shared_Escher_DgContainer) {
|
||||
// DgContainer
|
||||
$this->_object->setSpgrContainer($spgrContainer);
|
||||
} else {
|
||||
// SpgrContainer
|
||||
$this->_object->addChild($spgrContainer);
|
||||
}
|
||||
|
||||
$reader = new PHPExcel_Reader_Excel5_Escher($spgrContainer);
|
||||
$escher = $reader->load($recordData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read SpContainer record (Shape Container)
|
||||
*/
|
||||
private function _readSpContainer()
|
||||
{
|
||||
$length = $this->_GetInt4d($this->_data, $this->_pos + 4);
|
||||
$recordData = substr($this->_data, $this->_pos + 8, $length);
|
||||
|
||||
// add spContainer to spgrContainer
|
||||
$spContainer = new PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer();
|
||||
$this->_object->addChild($spContainer);
|
||||
|
||||
// move stream pointer to next record
|
||||
$this->_pos += 8 + $length;
|
||||
|
||||
// record is a container, read contents
|
||||
$reader = new PHPExcel_Reader_Excel5_Escher($spContainer);
|
||||
$escher = $reader->load($recordData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Spgr record (Shape Group)
|
||||
*/
|
||||
private function _readSpgr()
|
||||
{
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Sp record (Shape)
|
||||
*/
|
||||
private function _readSp()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read ClientTextbox record
|
||||
*/
|
||||
private function _readClientTextbox()
|
||||
{
|
||||
// offset: 0; size: 2; recVer and recInstance
|
||||
|
||||
// bit: 4-15; mask: 0xFFF0; recInstance
|
||||
$recInstance = (0xFFF0 & $this->_GetInt2d($this->_data, $this->_pos)) >> 4;
|
||||
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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(PHPExcel_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(PHPExcel_Cell::stringFromColumnIndex($c2) . ($r2 + 1));
|
||||
|
||||
// set the end offsetX
|
||||
$this->_object->setEndOffsetX($endOffsetX);
|
||||
|
||||
// set the end offsetY
|
||||
$this->_object->setEndOffsetY($endOffsetY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read ClientData record
|
||||
*/
|
||||
private function _readClientData()
|
||||
{
|
||||
$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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read OfficeArtRGFOPTE table of property-value pairs
|
||||
*
|
||||
* @param string $data Binary data
|
||||
* @param int $n Number of properties
|
||||
*/
|
||||
private function _readOfficeArtRGFOPTE($data, $n) {
|
||||
|
||||
$splicedComplexData = substr($data, 6 * $n);
|
||||
|
||||
// loop through property-value pairs
|
||||
for ($i = 0; $i < $n; ++$i) {
|
||||
// read 6 bytes at a time
|
||||
$fopte = substr($data, 6 * $i, 6);
|
||||
|
||||
// offset: 0; size: 2; opid
|
||||
$opid = $this->_GetInt2d($fopte, 0);
|
||||
|
||||
// bit: 0-13; mask: 0x3FFF; opid.opid
|
||||
$opidOpid = (0x3FFF & $opid) >> 0;
|
||||
|
||||
// bit: 14; mask 0x4000; 1 = value in op field is BLIP identifier
|
||||
$opidFBid = (0x4000 & $opid) >> 14;
|
||||
|
||||
// bit: 15; mask 0x8000; 1 = this is a complex property, op field specifies size of complex data
|
||||
$opidFComplex = (0x8000 & $opid) >> 15;
|
||||
|
||||
// offset: 2; size: 4; the value for this property
|
||||
$op = $this->_GetInt4d($fopte, 2);
|
||||
|
||||
if ($opidFComplex) {
|
||||
$complexData = substr($splicedComplexData, 0, $op);
|
||||
$splicedComplexData = substr($splicedComplexData, $op);
|
||||
|
||||
// we store string value with complex data
|
||||
$value = $complexData;
|
||||
} else {
|
||||
// we store integer value
|
||||
$value = $op;
|
||||
}
|
||||
|
||||
$this->_object->setOPT($opidOpid, $value);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read 16-bit unsigned integer
|
||||
*
|
||||
* @param string $data
|
||||
* @param int $pos
|
||||
* @return int
|
||||
*/
|
||||
private function _GetInt2d($data, $pos)
|
||||
{
|
||||
return ord($data[$pos]) | (ord($data[$pos + 1]) << 8);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read 32-bit signed integer
|
||||
*
|
||||
* @param string $data
|
||||
* @param int $pos
|
||||
* @return int
|
||||
*/
|
||||
private function _GetInt4d($data, $pos)
|
||||
{
|
||||
//return ord($data[$pos]) | (ord($data[$pos + 1]) << 8) |
|
||||
// (ord($data[$pos + 2]) << 16) | (ord($data[$pos + 3]) << 24);
|
||||
|
||||
// FIX: represent numbers correctly on 64-bit system
|
||||
// http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334
|
||||
$_or_24 = ord($data[$pos + 3]);
|
||||
if ($_or_24 >= 128) {
|
||||
// negative number
|
||||
$_ord_24 = -abs((256 - $_or_24) << 24);
|
||||
} else {
|
||||
$_ord_24 = ($_or_24 & 127) << 24;
|
||||
}
|
||||
return ord($data[$pos]) | (ord($data[$pos + 1]) << 8) | (ord($data[$pos + 2]) << 16) | $_ord_24;
|
||||
}
|
||||
|
||||
}
|
||||
47
include/PHPExcel/PHPExcel/Reader/IReadFilter.php
Executable file
47
include/PHPExcel/PHPExcel/Reader/IReadFilter.php
Executable file
@@ -0,0 +1,47 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Reader_IReadFilter
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
interface PHPExcel_Reader_IReadFilter
|
||||
{
|
||||
/**
|
||||
* Should this cell be read?
|
||||
*
|
||||
* @param $column String column index
|
||||
* @param $row Row index
|
||||
* @param $worksheetName Optional worksheet name
|
||||
* @return boolean
|
||||
*/
|
||||
public function readCell($column, $row, $worksheetName = '');
|
||||
}
|
||||
45
include/PHPExcel/PHPExcel/Reader/IReader.php
Executable file
45
include/PHPExcel/PHPExcel/Reader/IReader.php
Executable file
@@ -0,0 +1,45 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Reader_IReader
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
interface PHPExcel_Reader_IReader
|
||||
{
|
||||
/**
|
||||
* Loads PHPExcel from file
|
||||
*
|
||||
* @param string $pFileName
|
||||
* @throws Exception
|
||||
*/
|
||||
public function load($pFilename);
|
||||
}
|
||||
109
include/PHPExcel/PHPExcel/Reader/Serialized.php
Executable file
109
include/PHPExcel/PHPExcel/Reader/Serialized.php
Executable file
@@ -0,0 +1,109 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel */
|
||||
require_once 'PHPExcel.php';
|
||||
|
||||
/** PHPExcel_Reader_IReader */
|
||||
require_once 'PHPExcel/Reader/IReader.php';
|
||||
|
||||
/** PHPExcel_Shared_File */
|
||||
require_once 'PHPExcel/Shared/File.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Reader_Serialized
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Reader
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Reader_Serialized implements PHPExcel_Reader_IReader
|
||||
{
|
||||
/**
|
||||
* Loads PHPExcel Serialized file
|
||||
*
|
||||
* @param string $pFilename
|
||||
* @return PHPExcel
|
||||
* @throws Exception
|
||||
*/
|
||||
public function load($pFilename)
|
||||
{
|
||||
// Check if file exists
|
||||
if (!file_exists($pFilename)) {
|
||||
throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
|
||||
}
|
||||
|
||||
// Unserialize... First make sure the file supports it!
|
||||
if (!$this->fileSupportsUnserializePHPExcel($pFilename)) {
|
||||
throw new Exception("Invalid file format for PHPExcel_Reader_Serialized: " . $pFilename . ".");
|
||||
}
|
||||
|
||||
return $this->_loadSerialized($pFilename);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load PHPExcel Serialized file
|
||||
*
|
||||
* @param string $pFilename
|
||||
* @return PHPExcel
|
||||
*/
|
||||
private function _loadSerialized($pFilename) {
|
||||
$xmlData = simplexml_load_string(file_get_contents("zip://$pFilename#phpexcel.xml"));
|
||||
$excel = unserialize(base64_decode((string)$xmlData->data));
|
||||
|
||||
// Update media links
|
||||
for ($i = 0; $i < $excel->getSheetCount(); ++$i) {
|
||||
for ($j = 0; $j < $excel->getSheet($i)->getDrawingCollection()->count(); ++$j) {
|
||||
if ($excel->getSheet($i)->getDrawingCollection()->offsetGet($j) instanceof PHPExcl_Worksheet_BaseDrawing) {
|
||||
$imgTemp =& $excel->getSheet($i)->getDrawingCollection()->offsetGet($j);
|
||||
$imgTemp->setPath('zip://' . $pFilename . '#media/' . $imgTemp->getFilename(), false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $excel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does a file support UnserializePHPExcel ?
|
||||
*
|
||||
* @param string $pFilename
|
||||
* @throws Exception
|
||||
* @return boolean
|
||||
*/
|
||||
public function fileSupportsUnserializePHPExcel($pFilename = '') {
|
||||
// Check if file exists
|
||||
if (!file_exists($pFilename)) {
|
||||
throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
|
||||
}
|
||||
|
||||
// File exists, does it contain phpexcel.xml?
|
||||
return PHPExcel_Shared_File::file_exists("zip://$pFilename#phpexcel.xml");
|
||||
}
|
||||
}
|
||||
537
include/PHPExcel/PHPExcel/ReferenceHelper.php
Executable file
537
include/PHPExcel/PHPExcel/ReferenceHelper.php
Executable file
@@ -0,0 +1,537 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Worksheet */
|
||||
require_once 'PHPExcel/Worksheet.php';
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_Cell_DataType */
|
||||
require_once 'PHPExcel/Cell/DataType.php';
|
||||
|
||||
/** PHPExcel_Style */
|
||||
require_once 'PHPExcel/Style.php';
|
||||
|
||||
/** PHPExcel_Worksheet_Drawing */
|
||||
require_once 'PHPExcel/Worksheet/Drawing.php';
|
||||
|
||||
/** PHPExcel_Calculation_FormulaParser */
|
||||
require_once 'PHPExcel/Calculation/FormulaParser.php';
|
||||
|
||||
/** PHPExcel_Calculation_FormulaToken */
|
||||
require_once 'PHPExcel/Calculation/FormulaToken.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_ReferenceHelper (Singleton)
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_ReferenceHelper
|
||||
{
|
||||
/**
|
||||
* Instance of this class
|
||||
*
|
||||
* @var PHPExcel_ReferenceHelper
|
||||
*/
|
||||
private static $_instance;
|
||||
|
||||
/**
|
||||
* Get an instance of this class
|
||||
*
|
||||
* @return PHPExcel_ReferenceHelper
|
||||
*/
|
||||
public static function getInstance() {
|
||||
if (!isset(self::$_instance) || is_null(self::$_instance)) {
|
||||
self::$_instance = new PHPExcel_ReferenceHelper();
|
||||
}
|
||||
|
||||
return self::$_instance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_Calculation
|
||||
*/
|
||||
protected function __construct() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert a new column, updating all possible related data
|
||||
*
|
||||
* @param int $pBefore Insert before this one
|
||||
* @param int $pNumCols Number of columns to insert
|
||||
* @param int $pNumRows Number of rows to insert
|
||||
* @throws Exception
|
||||
*/
|
||||
public function insertNewBefore($pBefore = 'A1', $pNumCols = 0, $pNumRows = 0, PHPExcel_Worksheet $pSheet = null) {
|
||||
// Get a copy of the cell collection
|
||||
/*$aTemp = $pSheet->getCellCollection();
|
||||
$aCellCollection = array();
|
||||
foreach ($aTemp as $key => $value) {
|
||||
$aCellCollection[$key] = clone $value;
|
||||
}*/
|
||||
$aCellCollection = $pSheet->getCellCollection();
|
||||
|
||||
// Get coordinates of $pBefore
|
||||
$beforeColumn = 'A';
|
||||
$beforeRow = 1;
|
||||
list($beforeColumn, $beforeRow) = PHPExcel_Cell::coordinateFromString( $pBefore );
|
||||
|
||||
|
||||
// Remove cell styles?
|
||||
$highestColumn = $pSheet->getHighestColumn();
|
||||
$highestRow = $pSheet->getHighestRow();
|
||||
|
||||
if ($pNumCols < 0 && PHPExcel_Cell::columnIndexFromString($beforeColumn) - 2 + $pNumCols > 0) {
|
||||
for ($i = 1; $i <= $highestRow - 1; ++$i) {
|
||||
$pSheet->duplicateStyle(
|
||||
new PHPExcel_Style(),
|
||||
(PHPExcel_Cell::stringFromColumnIndex( PHPExcel_Cell::columnIndexFromString($beforeColumn) - 1 + $pNumCols ) . $i) . ':' . (PHPExcel_Cell::stringFromColumnIndex( PHPExcel_Cell::columnIndexFromString($beforeColumn) - 2 ) . $i)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if ($pNumRows < 0 && $beforeRow - 1 + $pNumRows > 0) {
|
||||
for ($i = PHPExcel_Cell::columnIndexFromString($beforeColumn) - 1; $i <= PHPExcel_Cell::columnIndexFromString($highestColumn) - 1; ++$i) {
|
||||
$pSheet->duplicateStyle(
|
||||
new PHPExcel_Style(),
|
||||
( PHPExcel_Cell::stringFromColumnIndex($i) . ($beforeRow + $pNumRows)) . ':' . ( PHPExcel_Cell::stringFromColumnIndex($i) . ($beforeRow - 1))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Loop trough cells, bottom-up, and change cell coordinates
|
||||
while ( ($cell = ($pNumCols < 0 || $pNumRows < 0) ? array_shift($aCellCollection) : array_pop($aCellCollection)) ) {
|
||||
// New coordinates
|
||||
$newCoordinates = PHPExcel_Cell::stringFromColumnIndex( PHPExcel_Cell::columnIndexFromString($cell->getColumn()) - 1 + $pNumCols ) . ($cell->getRow() + $pNumRows);
|
||||
|
||||
// Should the cell be updated?
|
||||
if (
|
||||
(PHPExcel_Cell::columnIndexFromString( $cell->getColumn() ) >= PHPExcel_Cell::columnIndexFromString($beforeColumn)) &&
|
||||
($cell->getRow() >= $beforeRow)
|
||||
) {
|
||||
|
||||
// Update cell styles
|
||||
$pSheet->duplicateStyle( $pSheet->getStyle($cell->getCoordinate()), $newCoordinates . ':' . $newCoordinates );
|
||||
$pSheet->duplicateStyle( $pSheet->getDefaultStyle(), $cell->getCoordinate() . ':' . $cell->getCoordinate() );
|
||||
|
||||
// Insert this cell at its new location
|
||||
if ($cell->getDataType() == PHPExcel_Cell_DataType::TYPE_FORMULA) {
|
||||
// Formula should be adjusted
|
||||
$pSheet->setCellValue(
|
||||
$newCoordinates
|
||||
, $this->updateFormulaReferences($cell->getValue(), $pBefore, $pNumCols, $pNumRows)
|
||||
);
|
||||
} else {
|
||||
// Formula should not be adjusted
|
||||
$pSheet->setCellValue($newCoordinates, $cell->getValue());
|
||||
}
|
||||
|
||||
// Clear the original cell
|
||||
$pSheet->setCellValue($cell->getCoordinate(), '');
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Duplicate styles for the newly inserted cells
|
||||
$highestColumn = $pSheet->getHighestColumn();
|
||||
$highestRow = $pSheet->getHighestRow();
|
||||
|
||||
if ($pNumCols > 0 && PHPExcel_Cell::columnIndexFromString($beforeColumn) - 2 > 0) {
|
||||
for ($i = $beforeRow; $i <= $highestRow - 1; ++$i) {
|
||||
|
||||
// Style
|
||||
$pSheet->duplicateStyle(
|
||||
$pSheet->getStyle(
|
||||
(PHPExcel_Cell::stringFromColumnIndex( PHPExcel_Cell::columnIndexFromString($beforeColumn) - 2 ) . $i)
|
||||
),
|
||||
($beforeColumn . $i) . ':' . (PHPExcel_Cell::stringFromColumnIndex( PHPExcel_Cell::columnIndexFromString($beforeColumn) - 2 + $pNumCols ) . $i)
|
||||
);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if ($pNumRows > 0 && $beforeRow - 1 > 0) {
|
||||
for ($i = PHPExcel_Cell::columnIndexFromString($beforeColumn) - 1; $i <= PHPExcel_Cell::columnIndexFromString($highestColumn) - 1; ++$i) {
|
||||
|
||||
// Style
|
||||
$pSheet->duplicateStyle(
|
||||
$pSheet->getStyle(
|
||||
(PHPExcel_Cell::stringFromColumnIndex($i) . ($beforeRow - 1))
|
||||
),
|
||||
(PHPExcel_Cell::stringFromColumnIndex($i) . $beforeRow) . ':' . (PHPExcel_Cell::stringFromColumnIndex($i) . ($beforeRow - 1 + $pNumRows))
|
||||
);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: column dimensions
|
||||
$aColumnDimensions = array_reverse($pSheet->getColumnDimensions(), true);
|
||||
if (count($aColumnDimensions) > 0) {
|
||||
foreach ($aColumnDimensions as $objColumnDimension) {
|
||||
$newReference = $this->updateCellReference($objColumnDimension->getColumnIndex() . '1', $pBefore, $pNumCols, $pNumRows);
|
||||
list($newReference) = PHPExcel_Cell::coordinateFromString($newReference);
|
||||
if ($objColumnDimension->getColumnIndex() != $newReference) {
|
||||
$objColumnDimension->setColumnIndex($newReference);
|
||||
}
|
||||
}
|
||||
$pSheet->refreshColumnDimensions();
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: row dimensions
|
||||
$aRowDimensions = array_reverse($pSheet->getRowDimensions(), true);
|
||||
if (count($aRowDimensions) > 0) {
|
||||
foreach ($aRowDimensions as $objRowDimension) {
|
||||
$newReference = $this->updateCellReference('A' . $objRowDimension->getRowIndex(), $pBefore, $pNumCols, $pNumRows);
|
||||
list(, $newReference) = PHPExcel_Cell::coordinateFromString($newReference);
|
||||
if ($objRowDimension->getRowIndex() != $newReference) {
|
||||
$objRowDimension->setRowIndex($newReference);
|
||||
}
|
||||
}
|
||||
$pSheet->refreshRowDimensions();
|
||||
|
||||
$copyDimension = $pSheet->getRowDimension($beforeRow - 1);
|
||||
for ($i = $beforeRow; $i <= $beforeRow - 1 + $pNumRows; ++$i) {
|
||||
$newDimension = $pSheet->getRowDimension($i);
|
||||
$newDimension->setRowHeight($copyDimension->getRowHeight());
|
||||
$newDimension->setVisible($copyDimension->getVisible());
|
||||
$newDimension->setOutlineLevel($copyDimension->getOutlineLevel());
|
||||
$newDimension->setCollapsed($copyDimension->getCollapsed());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: breaks
|
||||
$aBreaks = array_reverse($pSheet->getBreaks(), true);
|
||||
foreach ($aBreaks as $key => $value) {
|
||||
$newReference = $this->updateCellReference($key, $pBefore, $pNumCols, $pNumRows);
|
||||
if ($key != $newReference) {
|
||||
$pSheet->setBreak( $newReference, $value );
|
||||
$pSheet->setBreak( $key, PHPExcel_Worksheet::BREAK_NONE );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: merge cells
|
||||
$aMergeCells = array_reverse($pSheet->getMergeCells(), true);
|
||||
foreach ($aMergeCells as $key => $value) {
|
||||
$newReference = $this->updateCellReference($key, $pBefore, $pNumCols, $pNumRows);
|
||||
if ($key != $newReference) {
|
||||
$pSheet->mergeCells( $newReference );
|
||||
$pSheet->unmergeCells( $key );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: protected cells
|
||||
$aProtectedCells = array_reverse($pSheet->getProtectedCells(), true);
|
||||
foreach ($aProtectedCells as $key => $value) {
|
||||
$newReference = $this->updateCellReference($key, $pBefore, $pNumCols, $pNumRows);
|
||||
if ($key != $newReference) {
|
||||
$pSheet->protectCells( $newReference, $value, true );
|
||||
$pSheet->unprotectCells( $key );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: autofilter
|
||||
if ($pSheet->getAutoFilter() != '') {
|
||||
$pSheet->setAutoFilter( $this->updateCellReference($pSheet->getAutoFilter(), $pBefore, $pNumCols, $pNumRows) );
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: freeze pane
|
||||
if ($pSheet->getFreezePane() != '') {
|
||||
$pSheet->freezePane( $this->updateCellReference($pSheet->getFreezePane(), $pBefore, $pNumCols, $pNumRows) );
|
||||
}
|
||||
|
||||
|
||||
// Page setup
|
||||
if ($pSheet->getPageSetup()->isPrintAreaSet()) {
|
||||
$pSheet->getPageSetup()->setPrintArea( $this->updateCellReference($pSheet->getPageSetup()->getPrintArea(), $pBefore, $pNumCols, $pNumRows) );
|
||||
}
|
||||
|
||||
|
||||
// Update worksheet: drawings
|
||||
$aDrawings = $pSheet->getDrawingCollection();
|
||||
foreach ($aDrawings as $objDrawing) {
|
||||
$newReference = $this->updateCellReference($objDrawing->getCoordinates(), $pBefore, $pNumCols, $pNumRows);
|
||||
if ($objDrawing->getCoordinates() != $newReference) {
|
||||
$objDrawing->setCoordinates($newReference);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update workbook: named ranges
|
||||
if (count($pSheet->getParent()->getNamedRanges()) > 0) {
|
||||
foreach ($pSheet->getParent()->getNamedRanges() as $namedRange) {
|
||||
if ($namedRange->getWorksheet()->getHashCode() == $pSheet->getHashCode()) {
|
||||
$namedRange->setRange(
|
||||
$this->updateCellReference($namedRange->getRange(), $pBefore, $pNumCols, $pNumRows)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Garbage collect
|
||||
$pSheet->garbageCollect();
|
||||
}
|
||||
|
||||
/**
|
||||
* Update references within formulas
|
||||
*
|
||||
* @param string $pFormula Formula to update
|
||||
* @param int $pBefore Insert before this one
|
||||
* @param int $pNumCols Number of columns to insert
|
||||
* @param int $pNumRows Number of rows to insert
|
||||
* @return string Updated formula
|
||||
* @throws Exception
|
||||
*/
|
||||
public function updateFormulaReferences($pFormula = '', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0) {
|
||||
// Formula stack
|
||||
$executableFormulaArray = array();
|
||||
|
||||
// Parse formula into a tree of tokens
|
||||
$objParser = new PHPExcel_Calculation_FormulaParser($pFormula);
|
||||
|
||||
// Loop trough parsed tokens and create an executable formula
|
||||
$inFunction = false;
|
||||
$token = null;
|
||||
$tokenCount = $objParser->getTokenCount();
|
||||
for ($i = 0; $i < $tokenCount; ++$i) {
|
||||
$token = $objParser->getToken($i);
|
||||
|
||||
// Is it a cell reference? Not a cell range?
|
||||
if ( ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) &&
|
||||
($token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_RANGE) ) {
|
||||
// New cell reference
|
||||
$newCellReference = $this->updateCellReference($token->getValue(), $pBefore, $pNumCols, $pNumRows);
|
||||
|
||||
// Add adjusted cell coordinate to executable formula array
|
||||
$executableFormulaArray[] = $newCellReference;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a subexpression?
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) {
|
||||
// Temporary variable
|
||||
$tmp = '';
|
||||
switch($token->getTokenSubType()) {
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START:
|
||||
$tmp = '(';
|
||||
break;
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP:
|
||||
$tmp = ')';
|
||||
break;
|
||||
}
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = $tmp;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it a function?
|
||||
if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) {
|
||||
// Temporary variable
|
||||
$tmp = '';
|
||||
|
||||
// Check the function type
|
||||
if ($token->getValue() == 'ARRAY' || $token->getValue() == 'ARRAYROW') {
|
||||
// An array or an array row...
|
||||
$tmp = '(';
|
||||
} else {
|
||||
// A regular function call...
|
||||
switch($token->getTokenSubType()) {
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START:
|
||||
$tmp = strtoupper($token->getValue()) . '(';
|
||||
$inFunction = true;
|
||||
break;
|
||||
case PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP:
|
||||
$tmp = ')';
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = $tmp;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it text?
|
||||
if ( ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) &&
|
||||
($token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_TEXT) ) {
|
||||
// Add to executable formula array
|
||||
$executableFormulaArray[] = '"'.$token->getValue().'"';
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Is it something else?
|
||||
$executableFormulaArray[] = $token->getValue();
|
||||
}
|
||||
|
||||
// Return result
|
||||
return '=' . implode(' ', $executableFormulaArray);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update cell reference
|
||||
*
|
||||
* @param string $pCellRange Cell range
|
||||
* @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 range
|
||||
* @throws Exception
|
||||
*/
|
||||
public function updateCellReference($pCellRange = 'A1', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0) {
|
||||
// Is it a range or a single cell?
|
||||
if (strpos($pCellRange, ':') === false && strpos($pCellRange, ',') === false) {
|
||||
// Single cell
|
||||
return $this->_updateSingleCellReference($pCellRange, $pBefore, $pNumCols, $pNumRows);
|
||||
} else {
|
||||
// Range
|
||||
return $this->_updateCellRange($pCellRange, $pBefore, $pNumCols, $pNumRows);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update named formulas (i.e. containing worksheet references / named ranges)
|
||||
*
|
||||
* @param PHPExcel $pPhpExcel Object to update
|
||||
* @param string $oldName Old name (name to replace)
|
||||
* @param string $newName New name
|
||||
*/
|
||||
public function updateNamedFormulas(PHPExcel $pPhpExcel, $oldName = '', $newName = '') {
|
||||
foreach ($pPhpExcel->getWorksheetIterator() as $sheet) {
|
||||
foreach ($sheet->getCellCollection() as $cell) {
|
||||
if (!is_null($cell) && $cell->getDataType() == PHPExcel_Cell_DataType::TYPE_FORMULA) {
|
||||
$formula = $cell->getValue();
|
||||
if (strpos($formula, $oldName) !== false) {
|
||||
$formula = str_replace($oldName, $newName, $formula);
|
||||
$cell->setValue($formula, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update cell range
|
||||
*
|
||||
* @param string $pCellRange Cell range
|
||||
* @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 range
|
||||
* @throws Exception
|
||||
*/
|
||||
private function _updateCellRange($pCellRange = 'A1:A1', $pBefore = 'A1', $pNumCols = 0, $pNumRows = 0) {
|
||||
if (strpos($pCellRange,':') !== false || strpos($pCellRange, ',') !== false) {
|
||||
// Update range
|
||||
$range = PHPExcel_Cell::splitRange($pCellRange);
|
||||
for ($i = 0; $i < count($range); $i++) {
|
||||
for ($j = 0; $j < count($range[$i]); $j++) {
|
||||
$range[$i][$j] = $this->_updateSingleCellReference($range[$i][$j], $pBefore, $pNumCols, $pNumRows);
|
||||
}
|
||||
}
|
||||
|
||||
// Recreate range string
|
||||
return PHPExcel_Cell::buildRange($range);
|
||||
} else {
|
||||
throw new Exception("Only cell ranges may be passed to this method.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
$beforeColumn = 'A';
|
||||
$beforeRow = 1;
|
||||
list($beforeColumn, $beforeRow) = PHPExcel_Cell::coordinateFromString( $pBefore );
|
||||
|
||||
// Get coordinates
|
||||
$newColumn = 'A';
|
||||
$newRow = 1;
|
||||
list($newColumn, $newRow) = PHPExcel_Cell::coordinateFromString( $pCellReference );
|
||||
|
||||
// Verify which parts should be updated
|
||||
$updateColumn = (PHPExcel_Cell::columnIndexFromString($newColumn) >= PHPExcel_Cell::columnIndexFromString($beforeColumn))
|
||||
&& (strpos($newColumn, '$') === false)
|
||||
&& (strpos($beforeColumn, '$') === false);
|
||||
|
||||
$updateRow = ($newRow >= $beforeRow)
|
||||
&& (strpos($newRow, '$') === false)
|
||||
&& (strpos($beforeRow, '$') === false);
|
||||
|
||||
// Create new column reference
|
||||
if ($updateColumn) {
|
||||
$newColumn = PHPExcel_Cell::stringFromColumnIndex( PHPExcel_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.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* __clone implementation. Cloning should not be allowed in a Singleton!
|
||||
*
|
||||
* @throws Exception
|
||||
*/
|
||||
public final function __clone() {
|
||||
throw new Exception("Cloning a Singleton is not allowed!");
|
||||
}
|
||||
}
|
||||
289
include/PHPExcel/PHPExcel/RichText.php
Executable file
289
include/PHPExcel/PHPExcel/RichText.php
Executable file
@@ -0,0 +1,289 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_IComparable */
|
||||
require_once 'PHPExcel/IComparable.php';
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_RichText_ITextElement */
|
||||
require_once 'PHPExcel/RichText/ITextElement.php';
|
||||
|
||||
/** PHPExcel_RichText_TextElement */
|
||||
require_once 'PHPExcel/RichText/TextElement.php';
|
||||
|
||||
/** PHPExcel_RichText_Run */
|
||||
require_once 'PHPExcel/RichText/Run.php';
|
||||
|
||||
/** PHPExcel_Style_Font */
|
||||
require_once 'PHPExcel/Style/Font.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_RichText
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_RichText implements PHPExcel_IComparable
|
||||
{
|
||||
/**
|
||||
* Rich text elements
|
||||
*
|
||||
* @var PHPExcel_RichText_ITextElement[]
|
||||
*/
|
||||
private $_richTextElements;
|
||||
|
||||
/**
|
||||
* Parent cell
|
||||
*
|
||||
* @var PHPExcel_Cell
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_RichText instance
|
||||
*
|
||||
* @param PHPExcel_Cell $pParent
|
||||
* @throws Exception
|
||||
*/
|
||||
public function __construct(PHPExcel_Cell $pCell = null)
|
||||
{
|
||||
// Initialise variables
|
||||
$this->_richTextElements = array();
|
||||
|
||||
// Set parent?
|
||||
if (!is_null($pCell)) {
|
||||
// Set parent cell
|
||||
$this->_parent = $pCell;
|
||||
|
||||
// Add cell text and style
|
||||
if ($this->_parent->getValue() != "") {
|
||||
$objRun = new PHPExcel_RichText_Run($this->_parent->getValue());
|
||||
$objRun->setFont(clone $this->_parent->getParent()->getStyle($this->_parent->getCoordinate())->getFont());
|
||||
$this->addText($objRun);
|
||||
}
|
||||
|
||||
// Set parent value
|
||||
$this->_parent->setValue($this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add text
|
||||
*
|
||||
* @param PHPExcel_RichText_ITextElement $pText Rich text element
|
||||
* @throws Exception
|
||||
*/
|
||||
public function addText(PHPExcel_RichText_ITextElement $pText = null)
|
||||
{
|
||||
$this->_richTextElements[] = $pText;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create text
|
||||
*
|
||||
* @param string $pText Text
|
||||
* @return PHPExcel_RichText_TextElement
|
||||
* @throws Exception
|
||||
*/
|
||||
public function createText($pText = '')
|
||||
{
|
||||
$objText = new PHPExcel_RichText_TextElement($pText);
|
||||
$this->addText($objText);
|
||||
return $objText;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create text run
|
||||
*
|
||||
* @param string $pText Text
|
||||
* @return PHPExcel_RichText_Run
|
||||
* @throws Exception
|
||||
*/
|
||||
public function createTextRun($pText = '')
|
||||
{
|
||||
$objText = new PHPExcel_RichText_Run($pText);
|
||||
$this->addText($objText);
|
||||
return $objText;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get plain text
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getPlainText()
|
||||
{
|
||||
// Return value
|
||||
$returnValue = '';
|
||||
|
||||
// Loop trough all PHPExcel_RichText_ITextElement
|
||||
foreach ($this->_richTextElements as $text) {
|
||||
$returnValue .= $text->getText();
|
||||
}
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert to string
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString() {
|
||||
return $this->getPlainText();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Rich Text elements
|
||||
*
|
||||
* @return PHPExcel_RichText_ITextElement[]
|
||||
*/
|
||||
public function getRichTextElements()
|
||||
{
|
||||
return $this->_richTextElements;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Rich Text elements
|
||||
*
|
||||
* @param PHPExcel_RichText_ITextElement[] $pElements Array of elements
|
||||
* @throws Exception
|
||||
*/
|
||||
public function setRichTextElements($pElements = null)
|
||||
{
|
||||
if (is_array($pElements)) {
|
||||
$this->_richTextElements = $pElements;
|
||||
} else {
|
||||
throw new Exception("Invalid PHPExcel_RichText_ITextElement[] array passed.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parent
|
||||
*
|
||||
* @return PHPExcel_Cell
|
||||
*/
|
||||
public function getParent() {
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set parent
|
||||
*
|
||||
* @param PHPExcel_Cell $value
|
||||
*/
|
||||
public function setParent(PHPExcel_Cell $value) {
|
||||
// Set parent
|
||||
$this->_parent = $value;
|
||||
|
||||
// Set parent value
|
||||
$this->_parent->setValue($this);
|
||||
|
||||
// Verify style information
|
||||
|
||||
$sheet = $this->_parent->getParent();
|
||||
$cellFont = $sheet->getStyle($this->_parent->getCoordinate())->getFont();
|
||||
foreach ($this->getRichTextElements() as $element) {
|
||||
if (!($element instanceof PHPExcel_RichText_Run)) continue;
|
||||
|
||||
if ($element->getFont()->getHashCode() == $sheet->getDefaultStyle()->getFont()->getHashCode()) {
|
||||
if ($element->getFont()->getHashCode() != $cellFont->getHashCode()) {
|
||||
$element->setFont(clone $cellFont);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode() {
|
||||
$hashElements = '';
|
||||
foreach ($this->_richTextElements as $element) {
|
||||
$hashElements .= $element->getHashCode();
|
||||
}
|
||||
|
||||
return md5(
|
||||
$hashElements
|
||||
. __CLASS__
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Hash index
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_hashIndex;
|
||||
|
||||
/**
|
||||
* Get hash index
|
||||
*
|
||||
* Note that this index may vary during script execution! Only reliable moment is
|
||||
* while doing a write of a workbook and when changes are not allowed.
|
||||
*
|
||||
* @return string Hash index
|
||||
*/
|
||||
public function getHashIndex() {
|
||||
return $this->_hashIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set hash index
|
||||
*
|
||||
* Note that this index may vary during script execution! Only reliable moment is
|
||||
* while doing a write of a workbook and when changes are not allowed.
|
||||
*
|
||||
* @param string $value Hash index
|
||||
*/
|
||||
public function setHashIndex($value) {
|
||||
$this->_hashIndex = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if ($key == '_parent') continue;
|
||||
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
67
include/PHPExcel/PHPExcel/RichText/ITextElement.php
Executable file
67
include/PHPExcel/PHPExcel/RichText/ITextElement.php
Executable file
@@ -0,0 +1,67 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Style_Font */
|
||||
require_once 'PHPExcel/Style/Font.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_RichText_ITextElement
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
interface PHPExcel_RichText_ITextElement
|
||||
{
|
||||
/**
|
||||
* Get text
|
||||
*
|
||||
* @return string Text
|
||||
*/
|
||||
public function getText();
|
||||
|
||||
/**
|
||||
* Set text
|
||||
*
|
||||
* @param $pText string Text
|
||||
*/
|
||||
public function setText($pText = '');
|
||||
|
||||
/**
|
||||
* Get font
|
||||
*
|
||||
* @return PHPExcel_Style_Font
|
||||
*/
|
||||
public function getFont();
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode();
|
||||
}
|
||||
110
include/PHPExcel/PHPExcel/RichText/Run.php
Executable file
110
include/PHPExcel/PHPExcel/RichText/Run.php
Executable file
@@ -0,0 +1,110 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_RichText_ITextElement */
|
||||
require_once 'PHPExcel/RichText/ITextElement.php';
|
||||
|
||||
/** PHPExcel_RichText_TextElement */
|
||||
require_once 'PHPExcel/RichText/TextElement.php';
|
||||
|
||||
/** PHPExcel_Style_Font */
|
||||
require_once 'PHPExcel/Style/Font.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_RichText_Run
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_RichText_Run extends PHPExcel_RichText_TextElement implements PHPExcel_RichText_ITextElement
|
||||
{
|
||||
/**
|
||||
* Font
|
||||
*
|
||||
* @var PHPExcel_Style_Font
|
||||
*/
|
||||
private $_font;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_RichText_Run instance
|
||||
*
|
||||
* @param string $pText Text
|
||||
*/
|
||||
public function __construct($pText = '')
|
||||
{
|
||||
// Initialise variables
|
||||
$this->setText($pText);
|
||||
$this->_font = new PHPExcel_Style_Font();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get font
|
||||
*
|
||||
* @return PHPExcel_Style_Font
|
||||
*/
|
||||
public function getFont() {
|
||||
return $this->_font;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set font
|
||||
*
|
||||
* @param PHPExcel_Style_Font $pFont Font
|
||||
* @throws Exception
|
||||
*/
|
||||
public function setFont(PHPExcel_Style_Font $pFont = null) {
|
||||
$this->_font = $pFont;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode() {
|
||||
return md5(
|
||||
$this->getText()
|
||||
. $this->_font->getHashCode()
|
||||
. __CLASS__
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
113
include/PHPExcel/PHPExcel/RichText/TextElement.php
Executable file
113
include/PHPExcel/PHPExcel/RichText/TextElement.php
Executable file
@@ -0,0 +1,113 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_RichText_ITextElement */
|
||||
require_once 'PHPExcel/RichText/ITextElement.php';
|
||||
|
||||
/** PHPExcel_Style_Font */
|
||||
require_once 'PHPExcel/Style/Font.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_RichText_TextElement
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_RichText
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_RichText_TextElement implements PHPExcel_RichText_ITextElement
|
||||
{
|
||||
/**
|
||||
* Text
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_text;
|
||||
|
||||
/**
|
||||
* Create a new PHPExcel_RichText_TextElement instance
|
||||
*
|
||||
* @param string $pText Text
|
||||
*/
|
||||
public function __construct($pText = '')
|
||||
{
|
||||
// Initialise variables
|
||||
$this->_text = $pText;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get text
|
||||
*
|
||||
* @return string Text
|
||||
*/
|
||||
public function getText() {
|
||||
return $this->_text;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set text
|
||||
*
|
||||
* @param $pText string Text
|
||||
*/
|
||||
public function setText($pText = '') {
|
||||
$this->_text = $pText;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get font
|
||||
*
|
||||
* @return PHPExcel_Style_Font
|
||||
*/
|
||||
public function getFont() {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get hash code
|
||||
*
|
||||
* @return string Hash code
|
||||
*/
|
||||
public function getHashCode() {
|
||||
return md5(
|
||||
$this->_text
|
||||
. __CLASS__
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implement PHP __clone to create a deep clone, not just a shallow copy.
|
||||
*/
|
||||
public function __clone() {
|
||||
$vars = get_object_vars($this);
|
||||
foreach ($vars as $key => $value) {
|
||||
if (is_object($value)) {
|
||||
$this->$key = clone $value;
|
||||
} else {
|
||||
$this->$key = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
269
include/PHPExcel/PHPExcel/Shared/Date.php
Executable file
269
include/PHPExcel/PHPExcel/Shared/Date.php
Executable file
@@ -0,0 +1,269 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/** PHPExcel_Style_NumberFormat */
|
||||
require_once 'PHPExcel/Style/NumberFormat.php';
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Date
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Date
|
||||
{
|
||||
/** constants */
|
||||
const CALENDAR_WINDOWS_1900 = 1900; // Base date of 1st Jan 1900 = 1.0
|
||||
const CALENDAR_MAC_1904 = 1904; // Base date of 2nd Jan 1904 = 1.0
|
||||
|
||||
private static $ExcelBaseDate = self::CALENDAR_WINDOWS_1900;
|
||||
|
||||
public static $dateTimeObjectType = 'DateTime';
|
||||
|
||||
|
||||
/**
|
||||
* Set the Excel calendar (Windows 1900 or Mac 1904)
|
||||
*
|
||||
* @param integer $baseDate Excel base date
|
||||
* @return boolean Success or failure
|
||||
*/
|
||||
public static function setExcelCalendar($baseDate) {
|
||||
if (($baseDate == self::CALENDAR_WINDOWS_1900) ||
|
||||
($baseDate == self::CALENDAR_MAC_1904)) {
|
||||
self::$ExcelBaseDate = $baseDate;
|
||||
return True;
|
||||
}
|
||||
return False;
|
||||
} // function setExcelCalendar()
|
||||
|
||||
|
||||
/**
|
||||
* Return the Excel calendar (Windows 1900 or Mac 1904)
|
||||
*
|
||||
* @return integer $baseDate Excel base date
|
||||
*/
|
||||
public static function getExcelCalendar() {
|
||||
return self::$ExcelBaseDate;
|
||||
} // function getExcelCalendar()
|
||||
|
||||
|
||||
/**
|
||||
* Convert a date from Excel to PHP
|
||||
*
|
||||
* @param long $dateValue Excel date/time value
|
||||
* @return long PHP serialized date/time
|
||||
*/
|
||||
public static function ExcelToPHP($dateValue = 0) {
|
||||
if (self::$ExcelBaseDate == self::CALENDAR_WINDOWS_1900) {
|
||||
$myExcelBaseDate = 25569;
|
||||
// Adjust for the spurious 29-Feb-1900 (Day 60)
|
||||
if ($dateValue < 60) {
|
||||
--$myExcelBaseDate;
|
||||
}
|
||||
} else {
|
||||
$myExcelBaseDate = 24107;
|
||||
}
|
||||
|
||||
// Perform conversion
|
||||
if ($dateValue >= 1) {
|
||||
$utcDays = $dateValue - $myExcelBaseDate;
|
||||
$returnValue = (integer) round($utcDays * 24 * 60 * 60);
|
||||
} else {
|
||||
$hours = round($dateValue * 24);
|
||||
$mins = round($dateValue * 24 * 60) - round($hours * 60);
|
||||
$secs = round($dateValue * 24 * 60 * 60) - round($hours * 60 * 60) - round($mins * 60);
|
||||
$returnValue = (integer) mktime($hours, $mins, $secs);
|
||||
}
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
} // function ExcelToPHP()
|
||||
|
||||
|
||||
/**
|
||||
* Convert a date from Excel to a PHP Date/Time object
|
||||
*
|
||||
* @param long $dateValue Excel date/time value
|
||||
* @return long PHP date/time object
|
||||
*/
|
||||
public static function ExcelToPHPObject($dateValue = 0) {
|
||||
$dateTime = self::ExcelToPHP($dateValue);
|
||||
$days = floor($dateTime / 86400);
|
||||
$time = round((($dateTime / 86400) - $days) * 86400);
|
||||
$hours = round($time / 3600);
|
||||
$minutes = round($time / 60) - ($hours * 60);
|
||||
$seconds = round($time) - ($hours * 3600) - ($minutes * 60);
|
||||
$dateObj = date_create('1-Jan-1970+'.$days.' days');
|
||||
$dateObj->setTime($hours,$minutes,$seconds);
|
||||
return $dateObj;
|
||||
} // function ExcelToPHPObject()
|
||||
|
||||
|
||||
/**
|
||||
* Convert a date from PHP to Excel
|
||||
*
|
||||
* @param mixed $dateValue PHP serialized date/time or date object
|
||||
* @return mixed Excel date/time value
|
||||
* or boolean False on failure
|
||||
*/
|
||||
public static function PHPToExcel($dateValue = 0) {
|
||||
$saveTimeZone = date_default_timezone_get();
|
||||
date_default_timezone_set('UTC');
|
||||
$retValue = False;
|
||||
if ((is_object($dateValue)) && ($dateValue instanceof self::$dateTimeObjectType)) {
|
||||
$retValue = self::FormattedPHPToExcel( $dateValue->format('Y'), $dateValue->format('m'), $dateValue->format('d'),
|
||||
$dateValue->format('H'), $dateValue->format('i'), $dateValue->format('s')
|
||||
);
|
||||
} elseif (is_numeric($dateValue)) {
|
||||
$retValue = self::FormattedPHPToExcel( date('Y',$dateValue), date('m',$dateValue), date('d',$dateValue),
|
||||
date('H',$dateValue), date('i',$dateValue), date('s',$dateValue)
|
||||
);
|
||||
}
|
||||
date_default_timezone_set($saveTimeZone);
|
||||
|
||||
return $retValue;
|
||||
} // function PHPToExcel()
|
||||
|
||||
|
||||
/**
|
||||
* FormattedPHPToExcel
|
||||
*
|
||||
* @param long $year
|
||||
* @param long $month
|
||||
* @param long $day
|
||||
* @param long $hours
|
||||
* @param long $minutes
|
||||
* @param long $seconds
|
||||
* @return long Excel date/time value
|
||||
*/
|
||||
public static function FormattedPHPToExcel($year, $month, $day, $hours=0, $minutes=0, $seconds=0) {
|
||||
if (self::$ExcelBaseDate == self::CALENDAR_WINDOWS_1900) {
|
||||
//
|
||||
// Fudge factor for the erroneous fact that the year 1900 is treated as a Leap Year in MS Excel
|
||||
// This affects every date following 28th February 1900
|
||||
//
|
||||
$excel1900isLeapYear = True;
|
||||
if (($year == 1900) && ($month <= 2)) { $excel1900isLeapYear = False; }
|
||||
$myExcelBaseDate = 2415020;
|
||||
} else {
|
||||
$myExcelBaseDate = 2416481;
|
||||
$excel1900isLeapYear = False;
|
||||
}
|
||||
|
||||
// Julian base date Adjustment
|
||||
if ($month > 2) {
|
||||
$month = $month - 3;
|
||||
} else {
|
||||
$month = $month + 9;
|
||||
--$year;
|
||||
}
|
||||
|
||||
// Calculate the Julian Date, then subtract the Excel base date (JD 2415020 = 31-Dec-1899 Giving Excel Date of 0)
|
||||
$century = substr($year,0,2);
|
||||
$decade = substr($year,2,2);
|
||||
$excelDate = floor((146097 * $century) / 4) + floor((1461 * $decade) / 4) + floor((153 * $month + 2) / 5) + $day + 1721119 - $myExcelBaseDate + $excel1900isLeapYear;
|
||||
|
||||
$excelTime = (($hours * 3600) + ($minutes * 60) + $seconds) / 86400;
|
||||
|
||||
return (float) $excelDate + $excelTime;
|
||||
} // function FormattedPHPToExcel()
|
||||
|
||||
|
||||
/**
|
||||
* Is a given cell a date/time?
|
||||
*
|
||||
* @param PHPExcel_Cell $pCell
|
||||
* @return boolean
|
||||
*/
|
||||
public static function isDateTime(PHPExcel_Cell $pCell) {
|
||||
return self::isDateTimeFormat($pCell->getParent()->getStyle($pCell->getCoordinate())->getNumberFormat());
|
||||
} // function isDateTime()
|
||||
|
||||
|
||||
/**
|
||||
* Is a given number format a date/time?
|
||||
*
|
||||
* @param PHPExcel_Style_NumberFormat $pFormat
|
||||
* @return boolean
|
||||
*/
|
||||
public static function isDateTimeFormat(PHPExcel_Style_NumberFormat $pFormat) {
|
||||
return self::isDateTimeFormatCode($pFormat->getFormatCode());
|
||||
} // function isDateTimeFormat()
|
||||
|
||||
|
||||
private static $possibleDateFormatCharacters = 'ymdHis';
|
||||
|
||||
/**
|
||||
* Is a given number format code a date/time?
|
||||
*
|
||||
* @param string $pFormatCode
|
||||
* @return boolean
|
||||
*/
|
||||
public static function isDateTimeFormatCode($pFormatCode = '') {
|
||||
// Switch on formatcode
|
||||
switch ($pFormatCode) {
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDD2:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_DDMMYYYY:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_DMYSLASH:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_DMYMINUS:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_DMMINUS:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_MYMINUS:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_DATETIME:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME1:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME2:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME3:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME5:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME6:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME7:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME8:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_YYYYMMDDSLASH:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX14:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX16:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX17:
|
||||
case PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX22:
|
||||
return true;
|
||||
}
|
||||
|
||||
// Try checking for any of the date formatting characters that don't appear within square braces
|
||||
if (preg_match('/(^|\])[^\[]*['.self::$possibleDateFormatCharacters.']/i',$pFormatCode)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// No date...
|
||||
return false;
|
||||
} // function isDateTimeFormatCode()
|
||||
}
|
||||
133
include/PHPExcel/PHPExcel/Shared/Drawing.php
Executable file
133
include/PHPExcel/PHPExcel/Shared/Drawing.php
Executable file
@@ -0,0 +1,133 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Drawing
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Drawing
|
||||
{
|
||||
/**
|
||||
* Convert pixels to EMU
|
||||
*
|
||||
* @param int $pValue Value in pixels
|
||||
* @return int Value in EMU
|
||||
*/
|
||||
public static function pixelsToEMU($pValue = 0) {
|
||||
return round($pValue * 9525);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert EMU to pixels
|
||||
*
|
||||
* @param int $pValue Value in EMU
|
||||
* @return int Value in pixels
|
||||
*/
|
||||
public static function EMUToPixels($pValue = 0) {
|
||||
if ($pValue != 0) {
|
||||
return round($pValue / 9525);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert pixels to cell dimension
|
||||
*
|
||||
* @param int $pValue Value in pixels
|
||||
* @return int Value in cell dimension
|
||||
*/
|
||||
public static function pixelsToCellDimension($pValue = 0) {
|
||||
return $pValue / 12;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert cell width to pixels
|
||||
*
|
||||
* @param int $pValue Value in cell dimension
|
||||
* @return int Value in pixels
|
||||
*/
|
||||
public static function cellDimensionToPixels($pValue = 0) {
|
||||
if ($pValue != 0) {
|
||||
return $pValue * 12;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert pixels to points
|
||||
*
|
||||
* @param int $pValue Value in pixels
|
||||
* @return int Value in points
|
||||
*/
|
||||
public static function pixelsToPoints($pValue = 0) {
|
||||
return $pValue * 0.67777777;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert points width to pixels
|
||||
*
|
||||
* @param int $pValue Value in points
|
||||
* @return int Value in pixels
|
||||
*/
|
||||
public static function pointsToPixels($pValue = 0) {
|
||||
if ($pValue != 0) {
|
||||
return $pValue * 1.333333333;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert degrees to angle
|
||||
*
|
||||
* @param int $pValue Degrees
|
||||
* @return int Angle
|
||||
*/
|
||||
public static function degreesToAngle($pValue = 0) {
|
||||
return (int)round($pValue * 60000);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert angle to degrees
|
||||
*
|
||||
* @param int $pValue Angle
|
||||
* @return int Degrees
|
||||
*/
|
||||
public static function angleToDegrees($pValue = 0) {
|
||||
if ($pValue != 0) {
|
||||
return round($pValue / 60000);
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
91
include/PHPExcel/PHPExcel/Shared/Escher.php
Executable file
91
include/PHPExcel/PHPExcel/Shared/Escher.php
Executable file
@@ -0,0 +1,91 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher
|
||||
{
|
||||
/**
|
||||
* Drawing Group Container
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DggContainer
|
||||
*/
|
||||
private $_dggContainer;
|
||||
|
||||
/**
|
||||
* Drawing Container
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DgContainer
|
||||
*/
|
||||
private $_dgContainer;
|
||||
|
||||
/**
|
||||
* Get Drawing Group Container
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DgContainer
|
||||
*/
|
||||
public function getDggContainer()
|
||||
{
|
||||
return $this->_dggContainer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Drawing Group Container
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DggContainer $dggContainer
|
||||
*/
|
||||
public function setDggContainer($dggContainer)
|
||||
{
|
||||
return $this->_dggContainer = $dggContainer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Drawing Container
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DgContainer
|
||||
*/
|
||||
public function getDgContainer()
|
||||
{
|
||||
return $this->_dgContainer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set Drawing Container
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DgContainer $dgContainer
|
||||
*/
|
||||
public function setDgContainer($dgContainer)
|
||||
{
|
||||
return $this->_dgContainer = $dgContainer;
|
||||
}
|
||||
|
||||
}
|
||||
83
include/PHPExcel/PHPExcel/Shared/Escher/DgContainer.php
Executable file
83
include/PHPExcel/PHPExcel/Shared/Escher/DgContainer.php
Executable file
@@ -0,0 +1,83 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DgContainer
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DgContainer
|
||||
{
|
||||
/**
|
||||
* Drawing index, 1-based.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_dgId;
|
||||
|
||||
/**
|
||||
* Last shape index in this drawing
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_lastSpId;
|
||||
|
||||
private $_spgrContainer = null;
|
||||
|
||||
public function getDgId()
|
||||
{
|
||||
return $this->_dgId;
|
||||
}
|
||||
|
||||
public function setDgId($value)
|
||||
{
|
||||
$this->_dgId = $value;
|
||||
}
|
||||
|
||||
public function getLastSpId()
|
||||
{
|
||||
return $this->_lastSpId;
|
||||
}
|
||||
|
||||
public function setLastSpId($value)
|
||||
{
|
||||
$this->_lastSpId = $value;
|
||||
}
|
||||
|
||||
public function getSpgrContainer()
|
||||
{
|
||||
return $this->_spgrContainer;
|
||||
}
|
||||
|
||||
public function setSpgrContainer($spgrContainer)
|
||||
{
|
||||
return $this->_spgrContainer = $spgrContainer;
|
||||
}
|
||||
|
||||
}
|
||||
109
include/PHPExcel/PHPExcel/Shared/Escher/DgContainer/SpgrContainer.php
Executable file
109
include/PHPExcel/PHPExcel/Shared/Escher/DgContainer/SpgrContainer.php
Executable file
@@ -0,0 +1,109 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DgContainer_SpgrContainer
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DgContainer_SpgrContainer
|
||||
{
|
||||
/**
|
||||
* Parent Shape Group Container
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DgContainer_SpgrContainer
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* Shape Container collection
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_children = array();
|
||||
|
||||
/**
|
||||
* Set parent Shape Group Container
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DgContainer_SpgrContainer $parent
|
||||
*/
|
||||
public function setParent($parent)
|
||||
{
|
||||
$this->_parent = $parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the parent Shape Group Container if any
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DgContainer_SpgrContainer|null
|
||||
*/
|
||||
public function getParent()
|
||||
{
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a child. This will be either spgrContainer or spContainer
|
||||
*
|
||||
* @param mixed $child
|
||||
*/
|
||||
public function addChild($child)
|
||||
{
|
||||
$this->_children[] = $child;
|
||||
$child->setParent($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get collection of Shape Containers
|
||||
*/
|
||||
public function getChildren()
|
||||
{
|
||||
return $this->_children;
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively get all spContainers within this spgrContainer
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer[]
|
||||
*/
|
||||
public function getAllSpContainers()
|
||||
{
|
||||
$allSpContainers = array();
|
||||
|
||||
foreach ($this->_children as $child) {
|
||||
if ($child instanceof PHPExcel_Shared_Escher_DgContainer_SpgrContainer) {
|
||||
$allSpContainers = array_merge($allSpContainers, $child->getAllSpContainers());
|
||||
} else {
|
||||
$allSpContainers[] = $child;
|
||||
}
|
||||
}
|
||||
|
||||
return $allSpContainers;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,368 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer
|
||||
{
|
||||
/**
|
||||
* Parent Shape Group Container
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DgContainer_SpgrContainer
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* Is this a group shape?
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_spgr = false;
|
||||
|
||||
/**
|
||||
* Shape type
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_spType;
|
||||
|
||||
/**
|
||||
* Shape index (usually group shape has index 0, and the rest: 1,2,3...)
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
private $_spId;
|
||||
|
||||
/**
|
||||
* Array of options
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_OPT;
|
||||
|
||||
/**
|
||||
* Cell coordinates of upper-left corner of shape, e.g. 'A1'
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_startCoordinates;
|
||||
|
||||
/**
|
||||
* Horizontal offset of upper-left corner of shape measured in 1/1024 of column width
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_startOffsetX;
|
||||
|
||||
/**
|
||||
* Vertical offset of upper-left corner of shape measured in 1/256 of row height
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_startOffsetY;
|
||||
|
||||
/**
|
||||
* Cell coordinates of bottom-right corner of shape, e.g. 'B2'
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_endCoordinates;
|
||||
|
||||
/**
|
||||
* Horizontal offset of bottom-right corner of shape measured in 1/1024 of column width
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_endOffsetX;
|
||||
|
||||
/**
|
||||
* Vertical offset of bottom-right corner of shape measured in 1/256 of row height
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_endOffsetY;
|
||||
|
||||
/**
|
||||
* Set parent Shape Group Container
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DgContainer_SpgrContainer $parent
|
||||
*/
|
||||
public function setParent($parent)
|
||||
{
|
||||
$this->_parent = $parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the parent Shape Group Container
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DgContainer_SpgrContainer
|
||||
*/
|
||||
public function getParent()
|
||||
{
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set whether this is a group shape
|
||||
*
|
||||
* @param boolean $value
|
||||
*/
|
||||
public function setSpgr($value = false)
|
||||
{
|
||||
$this->_spgr = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether this is a group shape
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function getSpgr()
|
||||
{
|
||||
return $this->_spgr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the shape type
|
||||
*
|
||||
* @param int $value
|
||||
*/
|
||||
public function setSpType($value)
|
||||
{
|
||||
$this->_spType = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the shape type
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getSpType()
|
||||
{
|
||||
return $this->_spType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the shape index
|
||||
*
|
||||
* @param int $value
|
||||
*/
|
||||
public function setSpId($value)
|
||||
{
|
||||
$this->_spId = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the shape index
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getSpId()
|
||||
{
|
||||
return $this->_spId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set an option for the Shape Group Container
|
||||
*
|
||||
* @param int $property The number specifies the option
|
||||
* @param mixed $value
|
||||
*/
|
||||
public function setOPT($property, $value)
|
||||
{
|
||||
$this->_OPT[$property] = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an option for the Shape Group Container
|
||||
*
|
||||
* @param int $property The number specifies the option
|
||||
* @return mixed
|
||||
*/
|
||||
public function getOPT($property)
|
||||
{
|
||||
if (isset($this->_OPT[$property])) {
|
||||
return $this->_OPT[$property];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the collection of options
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getOPTCollection()
|
||||
{
|
||||
return $this->_OPT;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set cell coordinates of upper-left corner of shape
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setStartCoordinates($value = 'A1')
|
||||
{
|
||||
$this->_startCoordinates = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell coordinates of upper-left corner of shape
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getStartCoordinates()
|
||||
{
|
||||
return $this->_startCoordinates;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set offset in x-direction of upper-left corner of shape measured in 1/1024 of column width
|
||||
*
|
||||
* @param int $startOffsetX
|
||||
*/
|
||||
public function setStartOffsetX($startOffsetX = 0)
|
||||
{
|
||||
$this->_startOffsetX = $startOffsetX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get offset in x-direction of upper-left corner of shape measured in 1/1024 of column width
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getStartOffsetX()
|
||||
{
|
||||
return $this->_startOffsetX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set offset in y-direction of upper-left corner of shape measured in 1/256 of row height
|
||||
*
|
||||
* @param int $startOffsetY
|
||||
*/
|
||||
public function setStartOffsetY($startOffsetY = 0)
|
||||
{
|
||||
$this->_startOffsetY = $startOffsetY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get offset in y-direction of upper-left corner of shape measured in 1/256 of row height
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getStartOffsetY()
|
||||
{
|
||||
return $this->_startOffsetY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set cell coordinates of bottom-right corner of shape
|
||||
*
|
||||
* @param string $value
|
||||
*/
|
||||
public function setEndCoordinates($value = 'A1')
|
||||
{
|
||||
$this->_endCoordinates = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cell coordinates of bottom-right corner of shape
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getEndCoordinates()
|
||||
{
|
||||
return $this->_endCoordinates;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set offset in x-direction of bottom-right corner of shape measured in 1/1024 of column width
|
||||
*
|
||||
* @param int $startOffsetX
|
||||
*/
|
||||
public function setEndOffsetX($endOffsetX = 0)
|
||||
{
|
||||
$this->_endOffsetX = $endOffsetX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get offset in x-direction of bottom-right corner of shape measured in 1/1024 of column width
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getEndOffsetX()
|
||||
{
|
||||
return $this->_endOffsetX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set offset in y-direction of bottom-right corner of shape measured in 1/256 of row height
|
||||
*
|
||||
* @param int $endOffsetY
|
||||
*/
|
||||
public function setEndOffsetY($endOffsetY = 0)
|
||||
{
|
||||
$this->_endOffsetY = $endOffsetY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get offset in y-direction of bottom-right corner of shape measured in 1/256 of row height
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getEndOffsetY()
|
||||
{
|
||||
return $this->_endOffsetY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the nesting level of this spContainer. This is the number of spgrContainers between this spContainer and
|
||||
* the dgContainer. A value of 1 = immediately within first spgrContainer
|
||||
* Higher nesting level occurs if and only if spContainer is part of a shape group
|
||||
*
|
||||
* @return int Nesting level
|
||||
*/
|
||||
public function getNestingLevel()
|
||||
{
|
||||
$nestingLevel = 0;
|
||||
|
||||
$parent = $this->getParent();
|
||||
while ($parent instanceof PHPExcel_Shared_Escher_DgContainer_SpgrContainer) {
|
||||
++$nestingLevel;
|
||||
$parent = $parent->getParent();
|
||||
}
|
||||
|
||||
return $nestingLevel;
|
||||
}
|
||||
}
|
||||
177
include/PHPExcel/PHPExcel/Shared/Escher/DggContainer.php
Executable file
177
include/PHPExcel/PHPExcel/Shared/Escher/DggContainer.php
Executable file
@@ -0,0 +1,177 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DggContainer
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DggContainer
|
||||
{
|
||||
/**
|
||||
* Maximum shape index of all shapes in all drawings increased by one
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_spIdMax;
|
||||
|
||||
/**
|
||||
* Total number of drawings saved
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_cDgSaved;
|
||||
|
||||
/**
|
||||
* Total number of shapes saved (including group shapes)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_cSpSaved;
|
||||
|
||||
/**
|
||||
* BLIP Store Container
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DggContainer_BstoreContainer
|
||||
*/
|
||||
private $_bstoreContainer;
|
||||
|
||||
/**
|
||||
* Array of options for the drawing group
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_OPT = array();
|
||||
|
||||
/**
|
||||
* Get maximum shape index of all shapes in all drawings (plus one)
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getSpIdMax()
|
||||
{
|
||||
return $this->_spIdMax;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set maximum shape index of all shapes in all drawings (plus one)
|
||||
*
|
||||
* @param int
|
||||
*/
|
||||
public function setSpIdMax($value)
|
||||
{
|
||||
$this->_spIdMax = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get total number of drawings saved
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getCDgSaved()
|
||||
{
|
||||
return $this->_cDgSaved;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set total number of drawings saved
|
||||
*
|
||||
* @param int
|
||||
*/
|
||||
public function setCDgSaved($value)
|
||||
{
|
||||
$this->_cDgSaved = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get total number of shapes saved (including group shapes)
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getCSpSaved()
|
||||
{
|
||||
return $this->_cSpSaved;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set total number of shapes saved (including group shapes)
|
||||
*
|
||||
* @param int
|
||||
*/
|
||||
public function setCSpSaved($value)
|
||||
{
|
||||
$this->_cSpSaved = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get BLIP Store Container
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DggContainer_BstoreContainer
|
||||
*/
|
||||
public function getBstoreContainer()
|
||||
{
|
||||
return $this->_bstoreContainer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set BLIP Store Container
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DggContainer_BstoreContainer $bstoreContainer
|
||||
*/
|
||||
public function setBstoreContainer($bstoreContainer)
|
||||
{
|
||||
$this->_bstoreContainer = $bstoreContainer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set an option for the drawing group
|
||||
*
|
||||
* @param int $property The number specifies the option
|
||||
* @param mixed $value
|
||||
*/
|
||||
public function setOPT($property, $value)
|
||||
{
|
||||
$this->_OPT[$property] = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an option for the drawing group
|
||||
*
|
||||
* @param int $property The number specifies the option
|
||||
* @return mixed
|
||||
*/
|
||||
public function getOPT($property)
|
||||
{
|
||||
if (isset($this->_OPT[$property])) {
|
||||
return $this->_OPT[$property];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
65
include/PHPExcel/PHPExcel/Shared/Escher/DggContainer/BstoreContainer.php
Executable file
65
include/PHPExcel/PHPExcel/Shared/Escher/DggContainer/BstoreContainer.php
Executable file
@@ -0,0 +1,65 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DggContainer_BstoreContainer
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DggContainer_BstoreContainer
|
||||
{
|
||||
/**
|
||||
* BLIP Store Entries. Each of them holds one BLIP (Big Large Image or Picture)
|
||||
*
|
||||
* @var array
|
||||
*/
|
||||
private $_BSECollection = array();
|
||||
|
||||
/**
|
||||
* Add a BLIP Store Entry
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE $BSE
|
||||
*/
|
||||
public function addBSE($BSE)
|
||||
{
|
||||
$this->_BSECollection[] = $BSE;
|
||||
$BSE->setParent($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the collection of BLIP Store Entries
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE[]
|
||||
*/
|
||||
public function getBSECollection()
|
||||
{
|
||||
return $this->_BSECollection;
|
||||
}
|
||||
|
||||
}
|
||||
120
include/PHPExcel/PHPExcel/Shared/Escher/DggContainer/BstoreContainer/BSE.php
Executable file
120
include/PHPExcel/PHPExcel/Shared/Escher/DggContainer/BstoreContainer/BSE.php
Executable file
@@ -0,0 +1,120 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE
|
||||
{
|
||||
const BLIPTYPE_ERROR = 0x00;
|
||||
const BLIPTYPE_UNKNOWN = 0x01;
|
||||
const BLIPTYPE_EMF = 0x02;
|
||||
const BLIPTYPE_WMF = 0x03;
|
||||
const BLIPTYPE_PICT = 0x04;
|
||||
const BLIPTYPE_JPEG = 0x05;
|
||||
const BLIPTYPE_PNG = 0x06;
|
||||
const BLIPTYPE_DIB = 0x07;
|
||||
const BLIPTYPE_TIFF = 0x11;
|
||||
const BLIPTYPE_CMYKJPEG = 0x12;
|
||||
|
||||
/**
|
||||
* The parent BLIP Store Entry Container
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DggContainer_BstoreContainer
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* The BLIP (Big Large Image or Picture)
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip
|
||||
*/
|
||||
private $_blip;
|
||||
|
||||
/**
|
||||
* The BLIP type
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
private $_blipType;
|
||||
|
||||
/**
|
||||
* Set parent BLIP Store Entry Container
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DggContainer_BstoreContainer $parent
|
||||
*/
|
||||
public function setParent($parent)
|
||||
{
|
||||
$this->_parent = $parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the BLIP
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip
|
||||
*/
|
||||
public function getBlip()
|
||||
{
|
||||
return $this->_blip;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the BLIP
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip $blip
|
||||
*/
|
||||
public function setBlip($blip)
|
||||
{
|
||||
$this->_blip = $blip;
|
||||
$blip->setParent($this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the BLIP type
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function getBlipType()
|
||||
{
|
||||
return $this->_blipType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the BLIP type
|
||||
*
|
||||
* @param int
|
||||
*/
|
||||
public function setBlipType($blipType)
|
||||
{
|
||||
$this->_blipType = $blipType;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_Escher
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip
|
||||
{
|
||||
/**
|
||||
* The parent BSE
|
||||
*
|
||||
* @var PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE
|
||||
*/
|
||||
private $_parent;
|
||||
|
||||
/**
|
||||
* Raw image data
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
private $_data;
|
||||
|
||||
/**
|
||||
* Get the raw image data
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getData()
|
||||
{
|
||||
return $this->_data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the raw image data
|
||||
*
|
||||
* @param string
|
||||
*/
|
||||
public function setData($data)
|
||||
{
|
||||
$this->_data = $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set parent BSE
|
||||
*
|
||||
* @param PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE $parent
|
||||
*/
|
||||
public function setParent($parent)
|
||||
{
|
||||
$this->_parent = $parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parent BSE
|
||||
*
|
||||
* @return PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE $parent
|
||||
*/
|
||||
public function getParent()
|
||||
{
|
||||
return $this->_parent;
|
||||
}
|
||||
|
||||
}
|
||||
308
include/PHPExcel/PHPExcel/Shared/Excel5.php
Executable file
308
include/PHPExcel/PHPExcel/Shared/Excel5.php
Executable file
@@ -0,0 +1,308 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
/** PHPExcel_Cell */
|
||||
require_once 'PHPExcel/Cell.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Excel5
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Excel5
|
||||
{
|
||||
/**
|
||||
* Get the width of a column in pixels. We use the relationship y = ceil(7x) where
|
||||
* x is the width in intrinsic Excel units (measuring width in number of normal characters)
|
||||
* This holds for Arial 10
|
||||
*
|
||||
* @param PHPExcel_Worksheet $sheet The sheet
|
||||
* @param integer $col The column
|
||||
* @return integer The width in pixels
|
||||
*/
|
||||
public static function sizeCol($sheet, $col = 'A')
|
||||
{
|
||||
$columnDimensions = $sheet->getColumnDimensions();
|
||||
|
||||
// first find the true column width in pixels (uncollapsed and unhidden)
|
||||
if ( isset($columnDimensions[$col]) and $columnDimensions[$col]->getWidth() != -1 ) {
|
||||
|
||||
// then we have column dimension with explicit width
|
||||
$columnDimension = $columnDimensions[$col];
|
||||
$width = $columnDimension->getWidth();
|
||||
$pixelWidth = (int) ceil(7 * $width); // here we assume Arial 10
|
||||
|
||||
} else if ($sheet->getDefaultColumnDimension()->getWidth() != -1) {
|
||||
|
||||
// then we have default column dimension with explicit width
|
||||
$defaultColumnDimension = $sheet->getDefaultColumnDimension();
|
||||
$width = $defaultColumnDimension->getWidth();
|
||||
$pixelWidth = (int) ceil(7 * $width); // here we assume Arial 10
|
||||
|
||||
} else {
|
||||
$pixelWidth = 64; // here we assume Arial 10
|
||||
}
|
||||
|
||||
// now find the effective column width in pixels
|
||||
if (isset($columnDimensions[$col]) and !$columnDimensions[$col]->getVisible()) {
|
||||
$effectivePixelWidth = 0;
|
||||
} else {
|
||||
$effectivePixelWidth = $pixelWidth;
|
||||
}
|
||||
|
||||
return $effectivePixelWidth;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the height of a cell from user's units to pixels. By interpolation
|
||||
* the relationship is: y = 4/3x. If the height hasn't been set by the user we
|
||||
* use the default value. If the row is hidden we use a value of zero.
|
||||
*
|
||||
* @param PHPExcel_Worksheet $sheet The sheet
|
||||
* @param integer $row The row index (1-based)
|
||||
* @return integer The width in pixels
|
||||
*/
|
||||
public static function sizeRow($sheet, $row = 1)
|
||||
{
|
||||
$rowDimensions = $sheet->getRowDimensions();
|
||||
|
||||
// first find the true row height in pixels (uncollapsed and unhidden)
|
||||
if ( isset($rowDimensions[$row]) and $rowDimensions[$row]->getRowHeight() != -1) {
|
||||
|
||||
// then we have a row dimension
|
||||
$rowDimension = $rowDimensions[$row];
|
||||
$rowHeight = $rowDimension->getRowHeight();
|
||||
$pixelRowHeight = (int) ceil(4 * $rowHeight / 3); // here we assume Arial 10
|
||||
|
||||
} else if ($sheet->getDefaultRowDimension()->getRowHeight() != -1) {
|
||||
|
||||
// then we have a default row dimension with explicit height
|
||||
$defaultRowDimension = $sheet->getDefaultRowDimension();
|
||||
$rowHeight = $defaultRowDimension->getRowHeight();
|
||||
$pixelRowHeight = (int) ceil(4 * $rowHeight / 3); // here we assume Arial 10
|
||||
|
||||
} else {
|
||||
$pixelRowHeight = 17; // here we assume Arial 10
|
||||
}
|
||||
|
||||
// now find the effective row height in pixels
|
||||
if ( isset($rowDimensions[$row]) and !$rowDimensions[$row]->getVisible() ) {
|
||||
$effectivePixelRowHeight = 0;
|
||||
} else {
|
||||
$effectivePixelRowHeight = $pixelRowHeight;
|
||||
}
|
||||
|
||||
return $effectivePixelRowHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the horizontal distance in pixels between two anchors
|
||||
* The distanceX is found as sum of all the spanning columns widths minus correction for the two offsets
|
||||
*
|
||||
* @param PHPExcel_Worksheet $sheet
|
||||
* @param string $startColumn
|
||||
* @param integer $startOffset Offset within start cell measured in 1/1024 of the cell width
|
||||
* @param string $endColumn
|
||||
* @param integer $endOffset Offset within end cell measured in 1/1024 of the cell width
|
||||
* @return integer Horizontal measured in pixels
|
||||
*/
|
||||
public static function getDistanceX(PHPExcel_Worksheet $sheet, $startColumn = 'A', $startOffsetX = 0, $endColumn = 'A', $endOffsetX = 0)
|
||||
{
|
||||
$distanceX = 0;
|
||||
|
||||
// add the widths of the spanning columns
|
||||
$startColumnIndex = PHPExcel_Cell::columnIndexFromString($startColumn) - 1; // 1-based
|
||||
$endColumnIndex = PHPExcel_Cell::columnIndexFromString($endColumn) - 1; // 1-based
|
||||
for ($i = $startColumnIndex; $i <= $endColumnIndex; ++$i) {
|
||||
$distanceX += self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($i));
|
||||
}
|
||||
|
||||
// correct for offsetX in startcell
|
||||
$distanceX -= (int) floor(self::sizeCol($sheet, $startColumn) * $startOffsetX / 1024);
|
||||
|
||||
// correct for offsetX in endcell
|
||||
$distanceX -= (int) floor(self::sizeCol($sheet, $endColumn) * (1 - $endOffsetX / 1024));
|
||||
|
||||
return $distanceX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the vertical distance in pixels between two anchors
|
||||
* The distanceY is found as sum of all the spanning rows minus two offsets
|
||||
*
|
||||
* @param PHPExcel_Worksheet $sheet
|
||||
* @param string $startRow (1-based)
|
||||
* @param integer $startOffset Offset within start cell measured in 1/256 of the cell height
|
||||
* @param string $endRow (1-based)
|
||||
* @param integer $endOffset Offset within end cell measured in 1/256 of the cell height
|
||||
* @return integer Vertical distance measured in pixels
|
||||
*/
|
||||
public static function getDistanceY(PHPExcel_Worksheet $sheet, $startRow = 1, $startOffsetY = 0, $endRow = 1, $endOffsetY = 0)
|
||||
{
|
||||
$distanceY = 0;
|
||||
|
||||
// add the widths of the spanning rows
|
||||
for ($row = $startRow; $row <= $endRow; ++$row) {
|
||||
$distanceY += self::sizeRow($sheet, $row);
|
||||
}
|
||||
|
||||
// correct for offsetX in startcell
|
||||
$distanceY -= (int) floor(self::sizeRow($sheet, $startRow) * $startOffsetY / 256);
|
||||
|
||||
// correct for offsetX in endcell
|
||||
$distanceY -= (int) floor(self::sizeRow($sheet, $endRow) * (1 - $endOffsetY / 256));
|
||||
|
||||
return $distanceY;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 PHPExcel_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) = PHPExcel_Cell::coordinateFromString($coordinates);
|
||||
$col_start = PHPExcel_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, PHPExcel_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, PHPExcel_Cell::stringFromColumnIndex($col_end))) {
|
||||
$width -= self::sizeCol($sheet, PHPExcel_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, PHPExcel_Cell::stringFromColumnIndex($col_start)) == 0) {
|
||||
return;
|
||||
}
|
||||
if (self::sizeCol($sheet, PHPExcel_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, PHPExcel_Cell::stringFromColumnIndex($col_start)) * 1024;
|
||||
$y1 = $y1 / self::sizeRow($sheet, $row_start + 1) * 256;
|
||||
$x2 = $width / self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_end)) * 1024; // Distance to right side of object
|
||||
$y2 = $height / self::sizeRow($sheet, $row_end + 1) * 256; // Distance to bottom of object
|
||||
|
||||
$startCoordinates = PHPExcel_Cell::stringFromColumnIndex($col_start) . ($row_start + 1);
|
||||
$endCoordinates = PHPExcel_Cell::stringFromColumnIndex($col_end) . ($row_end + 1);
|
||||
|
||||
$twoAnchor = array(
|
||||
'startCoordinates' => $startCoordinates,
|
||||
'startOffsetX' => $x1,
|
||||
'startOffsetY' => $y1,
|
||||
'endCoordinates' => $endCoordinates,
|
||||
'endOffsetX' => $x2,
|
||||
'endOffsetY' => $y2,
|
||||
);
|
||||
|
||||
return $twoAnchor;
|
||||
}
|
||||
|
||||
}
|
||||
98
include/PHPExcel/PHPExcel/Shared/File.php
Executable file
98
include/PHPExcel/PHPExcel/Shared/File.php
Executable file
@@ -0,0 +1,98 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_File
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_File
|
||||
{
|
||||
/**
|
||||
* Verify if a file exists
|
||||
*
|
||||
* @param string $pFilename Filename
|
||||
* @return bool
|
||||
*/
|
||||
public static function file_exists($pFilename) {
|
||||
// Sick construction, but it seems that
|
||||
// file_exists returns strange values when
|
||||
// doing the original file_exists on ZIP archives...
|
||||
if ( strtolower(substr($pFilename, 0, 3)) == 'zip' ) {
|
||||
// Open ZIP file and verify if the file exists
|
||||
$zipFile = substr($pFilename, 6, strpos($pFilename, '#') - 6);
|
||||
$archiveFile = substr($pFilename, strpos($pFilename, '#') + 1);
|
||||
|
||||
$zip = new ZipArchive();
|
||||
if ($zip->open($zipFile) === true) {
|
||||
$returnValue = ($zip->getFromName($archiveFile) !== false);
|
||||
$zip->close();
|
||||
return $returnValue;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
// Regular file_exists
|
||||
return file_exists($pFilename);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns canonicalized absolute pathname, also for ZIP archives
|
||||
*
|
||||
* @param string $pFilename
|
||||
* @return string
|
||||
*/
|
||||
public static function realpath($pFilename) {
|
||||
// Returnvalue
|
||||
$returnValue = '';
|
||||
|
||||
// Try using realpath()
|
||||
$returnValue = realpath($pFilename);
|
||||
|
||||
// Found something?
|
||||
if ($returnValue == '' || is_null($returnValue)) {
|
||||
$pathArray = split('/' , $pFilename);
|
||||
while(in_array('..', $pathArray) && $pathArray[0] != '..') {
|
||||
for ($i = 0; $i < count($pathArray); ++$i) {
|
||||
if ($pathArray[$i] == '..' && $i > 0) {
|
||||
unset($pathArray[$i]);
|
||||
unset($pathArray[$i - 1]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
$returnValue = implode('/', $pathArray);
|
||||
}
|
||||
|
||||
// Return
|
||||
return $returnValue;
|
||||
}
|
||||
}
|
||||
114
include/PHPExcel/PHPExcel/Shared/Font.php
Executable file
114
include/PHPExcel/PHPExcel/Shared/Font.php
Executable file
@@ -0,0 +1,114 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_Font
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
*/
|
||||
class PHPExcel_Shared_Font
|
||||
{
|
||||
/**
|
||||
* Calculate an (approximate) OpenXML column width, based on font size and text contained
|
||||
*
|
||||
* @param int $fontSize Font size (in pixels or points)
|
||||
* @param bool $fontSizeInPixels Is the font size specified in pixels (true) or in points (false) ?
|
||||
* @param string $columnText Text to calculate width
|
||||
* @param int $rotation Rotation angle
|
||||
* @return int Column width
|
||||
*/
|
||||
public static function calculateColumnWidth($fontSize = 9, $fontSizeInPixels = false, $columnText = '', $rotation = 0) {
|
||||
if (!$fontSizeInPixels) {
|
||||
// Translate points size to pixel size
|
||||
$fontSize = PHPExcel_Shared_Font::fontSizeToPixels($fontSize);
|
||||
}
|
||||
|
||||
// If it is rich text, use rich text...
|
||||
if ($columnText instanceof PHPExcel_RichText) {
|
||||
$columnText = $columnText->getPlainText();
|
||||
}
|
||||
|
||||
// Only measure the part before the first newline character
|
||||
if (strpos($columnText, "\r") !== false) {
|
||||
$columnText = substr($columnText, 0, strpos($columnText, "\r"));
|
||||
}
|
||||
if (strpos($columnText, "\n") !== false) {
|
||||
$columnText = substr($columnText, 0, strpos($columnText, "\n"));
|
||||
}
|
||||
|
||||
// Calculate column width
|
||||
$columnWidth = ((strlen($columnText) * $fontSize + 5) / $fontSize * 256 ) / 256;
|
||||
|
||||
// Calculate approximate rotated column width
|
||||
if ($rotation !== 0) {
|
||||
if ($rotation == -165) {
|
||||
// stacked text
|
||||
$columnWidth = 4; // approximation
|
||||
} else {
|
||||
// rotated text
|
||||
$columnWidth = $columnWidth * cos(deg2rad($rotation))
|
||||
+ $fontSize * abs(sin(deg2rad($rotation))) / 5; // approximation
|
||||
}
|
||||
}
|
||||
|
||||
// Return
|
||||
return round($columnWidth, 6);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate an (approximate) pixel size, based on a font points size
|
||||
*
|
||||
* @param int $fontSizeInPoints Font size (in points)
|
||||
* @return int Font size (in pixels)
|
||||
*/
|
||||
public static function fontSizeToPixels($fontSizeInPoints = 12) {
|
||||
return ((16 / 12) * $fontSizeInPoints);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate an (approximate) pixel size, based on inch size
|
||||
*
|
||||
* @param int $sizeInInch Font size (in inch)
|
||||
* @return int Size (in pixels)
|
||||
*/
|
||||
public static function inchSizeToPixels($sizeInInch = 1) {
|
||||
return ($sizeInInch * 96);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate an (approximate) pixel size, based on centimeter size
|
||||
*
|
||||
* @param int $sizeInCm Font size (in centimeters)
|
||||
* @return int Size (in pixels)
|
||||
*/
|
||||
public static function centimeterSizeToPixels($sizeInCm = 1) {
|
||||
return ($sizeInCm * 37.795275591);
|
||||
}
|
||||
}
|
||||
133
include/PHPExcel/PHPExcel/Shared/JAMA/CholeskyDecomposition.php
Executable file
133
include/PHPExcel/PHPExcel/Shared/JAMA/CholeskyDecomposition.php
Executable file
@@ -0,0 +1,133 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* Cholesky decomposition class
|
||||
*
|
||||
* For a symmetric, positive definite matrix A, the Cholesky decomposition
|
||||
* is an lower triangular matrix L so that A = L*L'.
|
||||
*
|
||||
* If the matrix is not symmetric or positive definite, the constructor
|
||||
* returns a partial decomposition and sets an internal flag that may
|
||||
* be queried by the isSPD() method.
|
||||
*
|
||||
* @author Paul Meagher
|
||||
* @author Michael Bommarito
|
||||
* @version 1.2
|
||||
*/
|
||||
class CholeskyDecomposition {
|
||||
/**
|
||||
* Decomposition storage
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
var $L = array();
|
||||
|
||||
/**
|
||||
* Matrix row and column dimension
|
||||
* @var int
|
||||
* @access private
|
||||
*/
|
||||
var $m;
|
||||
|
||||
/**
|
||||
* Symmetric positive definite flag
|
||||
* @var boolean
|
||||
* @access private
|
||||
*/
|
||||
var $isspd = true;
|
||||
|
||||
/**
|
||||
* CholeskyDecomposition
|
||||
* Class constructor - decomposes symmetric positive definite matrix
|
||||
* @param mixed Matrix square symmetric positive definite matrix
|
||||
*/
|
||||
function CholeskyDecomposition( $A = null ) {
|
||||
if( is_a($A, 'Matrix') ) {
|
||||
$this->L = $A->getArray();
|
||||
$this->m = $A->getRowDimension();
|
||||
|
||||
for( $i = 0; $i < $this->m; $i++ ) {
|
||||
for( $j = $i; $j < $this->m; $j++ ) {
|
||||
for( $sum = $this->L[$i][$j], $k = $i - 1; $k >= 0; $k-- )
|
||||
$sum -= $this->L[$i][$k] * $this->L[$j][$k];
|
||||
|
||||
if( $i == $j ) {
|
||||
if( $sum >= 0 ) {
|
||||
$this->L[$i][$i] = sqrt( $sum );
|
||||
} else {
|
||||
$this->isspd = false;
|
||||
}
|
||||
} else {
|
||||
if( $this->L[$i][$i] != 0 )
|
||||
$this->L[$j][$i] = $sum / $this->L[$i][$i];
|
||||
}
|
||||
}
|
||||
|
||||
for ($k = $i+1; $k < $this->m; $k++)
|
||||
$this->L[$i][$k] = 0.0;
|
||||
}
|
||||
} else {
|
||||
trigger_error(ArgumentTypeException, ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the matrix symmetric and positive definite?
|
||||
* @return boolean
|
||||
*/
|
||||
function isSPD () {
|
||||
return $this->isspd;
|
||||
}
|
||||
|
||||
/**
|
||||
* getL
|
||||
* Return triangular factor.
|
||||
* @return Matrix Lower triangular matrix
|
||||
*/
|
||||
function getL () {
|
||||
return new Matrix($this->L);
|
||||
}
|
||||
|
||||
/**
|
||||
* Solve A*X = B
|
||||
* @param $B Row-equal matrix
|
||||
* @return Matrix L * L' * X = B
|
||||
*/
|
||||
function solve ( $B = null ) {
|
||||
if( is_a($B, 'Matrix') ) {
|
||||
if ($B->getRowDimension() == $this->m) {
|
||||
if ($this->isspd) {
|
||||
$X = $B->getArrayCopy();
|
||||
$nx = $B->getColumnDimension();
|
||||
|
||||
for ($k = 0; $k < $this->m; $k++) {
|
||||
for ($i = $k + 1; $i < $this->m; $i++)
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X[$i][$j] -= $X[$k][$j] * $this->L[$i][$k];
|
||||
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X[$k][$j] /= $this->L[$k][$k];
|
||||
}
|
||||
|
||||
for ($k = $this->m - 1; $k >= 0; $k--) {
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X[$k][$j] /= $this->L[$k][$k];
|
||||
|
||||
for ($i = 0; $i < $k; $i++)
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X[$i][$j] -= $X[$k][$j] * $this->L[$k][$i];
|
||||
}
|
||||
|
||||
return new Matrix($X, $this->m, $nx);
|
||||
} else {
|
||||
trigger_error(MatrixSPDException, ERROR);
|
||||
}
|
||||
} else {
|
||||
trigger_error(MatrixDimensionException, ERROR);
|
||||
}
|
||||
} else {
|
||||
trigger_error(ArgumentTypeException, ERROR);
|
||||
}
|
||||
}
|
||||
}
|
||||
789
include/PHPExcel/PHPExcel/Shared/JAMA/EigenvalueDecomposition.php
Executable file
789
include/PHPExcel/PHPExcel/Shared/JAMA/EigenvalueDecomposition.php
Executable file
@@ -0,0 +1,789 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* Class to obtain eigenvalues and eigenvectors of a real matrix.
|
||||
*
|
||||
* If A is symmetric, then A = V*D*V' where the eigenvalue matrix D
|
||||
* is diagonal and the eigenvector matrix V is orthogonal (i.e.
|
||||
* A = V.times(D.times(V.transpose())) and V.times(V.transpose())
|
||||
* equals the identity matrix).
|
||||
*
|
||||
* If A is not symmetric, then the eigenvalue matrix D is block diagonal
|
||||
* with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
|
||||
* lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The
|
||||
* columns of V represent the eigenvectors in the sense that A*V = V*D,
|
||||
* i.e. A.times(V) equals V.times(D). The matrix V may be badly
|
||||
* conditioned, or even singular, so the validity of the equation
|
||||
* A = V*D*inverse(V) depends upon V.cond().
|
||||
*
|
||||
* @author Paul Meagher
|
||||
* @license PHP v3.0
|
||||
* @version 1.1
|
||||
*/
|
||||
class EigenvalueDecomposition {
|
||||
|
||||
/**
|
||||
* Row and column dimension (square matrix).
|
||||
* @var int
|
||||
*/
|
||||
var $n;
|
||||
|
||||
/**
|
||||
* Internal symmetry flag.
|
||||
|
||||
* @var int
|
||||
*/
|
||||
var $issymmetric;
|
||||
|
||||
/**
|
||||
* Arrays for internal storage of eigenvalues.
|
||||
* @var array
|
||||
*/
|
||||
var $d = array();
|
||||
var $e = array();
|
||||
|
||||
/**
|
||||
* Array for internal storage of eigenvectors.
|
||||
* @var array
|
||||
*/
|
||||
var $V = array();
|
||||
|
||||
/**
|
||||
* Array for internal storage of nonsymmetric Hessenberg form.
|
||||
* @var array
|
||||
*/
|
||||
var $H = array();
|
||||
|
||||
/**
|
||||
* Working storage for nonsymmetric algorithm.
|
||||
* @var array
|
||||
*/
|
||||
var $ort;
|
||||
|
||||
/**
|
||||
* Used for complex scalar division.
|
||||
* @var float
|
||||
*/
|
||||
var $cdivr;
|
||||
var $cdivi;
|
||||
|
||||
/**
|
||||
* Symmetric Householder reduction to tridiagonal form.
|
||||
* @access private
|
||||
*/
|
||||
function tred2 () {
|
||||
// This is derived from the Algol procedures tred2 by
|
||||
// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
|
||||
// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
|
||||
// Fortran subroutine in EISPACK.
|
||||
$this->d = $this->V[$this->n-1];
|
||||
// Householder reduction to tridiagonal form.
|
||||
for ($i = $this->n-1; $i > 0; $i--) {
|
||||
$i_ = $i -1;
|
||||
// Scale to avoid under/overflow.
|
||||
$h = $scale = 0.0;
|
||||
$scale += array_sum(array_map(abs, $this->d));
|
||||
if ($scale == 0.0) {
|
||||
$this->e[$i] = $this->d[$i_];
|
||||
$this->d = array_slice($this->V[$i_], 0, $i_);
|
||||
for ($j = 0; $j < $i; $j++) {
|
||||
$this->V[$j][$i] = $this->V[$i][$j] = 0.0;
|
||||
}
|
||||
} else {
|
||||
// Generate Householder vector.
|
||||
for ($k = 0; $k < $i; $k++) {
|
||||
$this->d[$k] /= $scale;
|
||||
$h += pow($this->d[$k], 2);
|
||||
}
|
||||
$f = $this->d[$i_];
|
||||
$g = sqrt($h);
|
||||
if ($f > 0)
|
||||
$g = -$g;
|
||||
$this->e[$i] = $scale * $g;
|
||||
$h = $h - $f * $g;
|
||||
$this->d[$i_] = $f - $g;
|
||||
for ($j = 0; $j < $i; $j++)
|
||||
$this->e[$j] = 0.0;
|
||||
// Apply similarity transformation to remaining columns.
|
||||
for ($j = 0; $j < $i; $j++) {
|
||||
$f = $this->d[$j];
|
||||
$this->V[$j][$i] = $f;
|
||||
$g = $this->e[$j] + $this->V[$j][$j] * $f;
|
||||
for ($k = $j+1; $k <= $i_; $k++) {
|
||||
$g += $this->V[$k][$j] * $this->d[$k];
|
||||
$this->e[$k] += $this->V[$k][$j] * $f;
|
||||
}
|
||||
$this->e[$j] = $g;
|
||||
}
|
||||
$f = 0.0;
|
||||
for ($j = 0; $j < $i; $j++) {
|
||||
$this->e[$j] /= $h;
|
||||
$f += $this->e[$j] * $this->d[$j];
|
||||
}
|
||||
$hh = $f / (2 * $h);
|
||||
for ($j=0; $j < $i; $j++)
|
||||
$this->e[$j] -= $hh * $this->d[$j];
|
||||
for ($j = 0; $j < $i; $j++) {
|
||||
$f = $this->d[$j];
|
||||
$g = $this->e[$j];
|
||||
for ($k = $j; $k <= $i_; $k++)
|
||||
$this->V[$k][$j] -= ($f * $this->e[$k] + $g * $this->d[$k]);
|
||||
$this->d[$j] = $this->V[$i-1][$j];
|
||||
$this->V[$i][$j] = 0.0;
|
||||
}
|
||||
}
|
||||
$this->d[$i] = $h;
|
||||
}
|
||||
// Accumulate transformations.
|
||||
for ($i = 0; $i < $this->n-1; $i++) {
|
||||
$this->V[$this->n-1][$i] = $this->V[$i][$i];
|
||||
$this->V[$i][$i] = 1.0;
|
||||
$h = $this->d[$i+1];
|
||||
if ($h != 0.0) {
|
||||
for ($k = 0; $k <= $i; $k++)
|
||||
$this->d[$k] = $this->V[$k][$i+1] / $h;
|
||||
for ($j = 0; $j <= $i; $j++) {
|
||||
$g = 0.0;
|
||||
for ($k = 0; $k <= $i; $k++)
|
||||
$g += $this->V[$k][$i+1] * $this->V[$k][$j];
|
||||
for ($k = 0; $k <= $i; $k++)
|
||||
$this->V[$k][$j] -= $g * $this->d[$k];
|
||||
}
|
||||
}
|
||||
for ($k = 0; $k <= $i; $k++)
|
||||
$this->V[$k][$i+1] = 0.0;
|
||||
}
|
||||
|
||||
$this->d = $this->V[$this->n-1];
|
||||
$this->V[$this->n-1] = array_fill(0, $j, 0.0);
|
||||
$this->V[$this->n-1][$this->n-1] = 1.0;
|
||||
$this->e[0] = 0.0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Symmetric tridiagonal QL algorithm.
|
||||
*
|
||||
* This is derived from the Algol procedures tql2, by
|
||||
* Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
|
||||
* Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
|
||||
* Fortran subroutine in EISPACK.
|
||||
*
|
||||
* @access private
|
||||
*/
|
||||
function tql2 () {
|
||||
for ($i = 1; $i < $this->n; $i++)
|
||||
$this->e[$i-1] = $this->e[$i];
|
||||
$this->e[$this->n-1] = 0.0;
|
||||
$f = 0.0;
|
||||
$tst1 = 0.0;
|
||||
$eps = pow(2.0,-52.0);
|
||||
for ($l = 0; $l < $this->n; $l++) {
|
||||
// Find small subdiagonal element
|
||||
$tst1 = max($tst1, abs($this->d[$l]) + abs($this->e[$l]));
|
||||
$m = $l;
|
||||
while ($m < $this->n) {
|
||||
if (abs($this->e[$m]) <= $eps * $tst1)
|
||||
break;
|
||||
$m++;
|
||||
}
|
||||
// If m == l, $this->d[l] is an eigenvalue,
|
||||
// otherwise, iterate.
|
||||
if ($m > $l) {
|
||||
$iter = 0;
|
||||
do {
|
||||
// Could check iteration count here.
|
||||
$iter += 1;
|
||||
// Compute implicit shift
|
||||
$g = $this->d[$l];
|
||||
$p = ($this->d[$l+1] - $g) / (2.0 * $this->e[$l]);
|
||||
$r = hypo($p, 1.0);
|
||||
if ($p < 0)
|
||||
$r *= -1;
|
||||
$this->d[$l] = $this->e[$l] / ($p + $r);
|
||||
$this->d[$l+1] = $this->e[$l] * ($p + $r);
|
||||
$dl1 = $this->d[$l+1];
|
||||
$h = $g - $this->d[$l];
|
||||
for ($i = $l + 2; $i < $this->n; $i++)
|
||||
$this->d[$i] -= $h;
|
||||
$f += $h;
|
||||
// Implicit QL transformation.
|
||||
$p = $this->d[$m];
|
||||
$c = 1.0;
|
||||
$c2 = $c3 = $c;
|
||||
$el1 = $this->e[$l + 1];
|
||||
$s = $s2 = 0.0;
|
||||
for ($i = $m-1; $i >= $l; $i--) {
|
||||
$c3 = $c2;
|
||||
$c2 = $c;
|
||||
$s2 = $s;
|
||||
$g = $c * $this->e[$i];
|
||||
$h = $c * $p;
|
||||
$r = hypo($p, $this->e[$i]);
|
||||
$this->e[$i+1] = $s * $r;
|
||||
$s = $this->e[$i] / $r;
|
||||
$c = $p / $r;
|
||||
$p = $c * $this->d[$i] - $s * $g;
|
||||
$this->d[$i+1] = $h + $s * ($c * $g + $s * $this->d[$i]);
|
||||
// Accumulate transformation.
|
||||
for ($k = 0; $k < $this->n; $k++) {
|
||||
$h = $this->V[$k][$i+1];
|
||||
$this->V[$k][$i+1] = $s * $this->V[$k][$i] + $c * $h;
|
||||
$this->V[$k][$i] = $c * $this->V[$k][$i] - $s * $h;
|
||||
}
|
||||
}
|
||||
$p = -$s * $s2 * $c3 * $el1 * $this->e[$l] / $dl1;
|
||||
$this->e[$l] = $s * $p;
|
||||
$this->d[$l] = $c * $p;
|
||||
// Check for convergence.
|
||||
} while (abs($this->e[$l]) > $eps * $tst1);
|
||||
}
|
||||
$this->d[$l] = $this->d[$l] + $f;
|
||||
$this->e[$l] = 0.0;
|
||||
}
|
||||
// Sort eigenvalues and corresponding vectors.
|
||||
for ($i = 0; $i < $this->n - 1; $i++) {
|
||||
$k = $i;
|
||||
$p = $this->d[$i];
|
||||
for ($j = $i+1; $j < $this->n; $j++) {
|
||||
if ($this->d[$j] < $p) {
|
||||
$k = $j;
|
||||
$p = $this->d[$j];
|
||||
}
|
||||
}
|
||||
if ($k != $i) {
|
||||
$this->d[$k] = $this->d[$i];
|
||||
$this->d[$i] = $p;
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
$p = $this->V[$j][$i];
|
||||
$this->V[$j][$i] = $this->V[$j][$k];
|
||||
$this->V[$j][$k] = $p;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Nonsymmetric reduction to Hessenberg form.
|
||||
*
|
||||
* This is derived from the Algol procedures orthes and ortran,
|
||||
* by Martin and Wilkinson, Handbook for Auto. Comp.,
|
||||
* Vol.ii-Linear Algebra, and the corresponding
|
||||
* Fortran subroutines in EISPACK.
|
||||
*
|
||||
* @access private
|
||||
*/
|
||||
function orthes () {
|
||||
$low = 0;
|
||||
$high = $this->n-1;
|
||||
for ($m = $low+1; $m <= $high-1; $m++) {
|
||||
// Scale column.
|
||||
$scale = 0.0;
|
||||
for ($i = $m; $i <= $high; $i++)
|
||||
$scale = $scale + abs($this->H[$i][$m-1]);
|
||||
if ($scale != 0.0) {
|
||||
// Compute Householder transformation.
|
||||
$h = 0.0;
|
||||
for ($i = $high; $i >= $m; $i--) {
|
||||
$this->ort[$i] = $this->H[$i][$m-1]/$scale;
|
||||
$h += $this->ort[$i] * $this->ort[$i];
|
||||
}
|
||||
$g = sqrt($h);
|
||||
if ($this->ort[$m] > 0)
|
||||
$g *= -1;
|
||||
$h -= $this->ort[$m] * $g;
|
||||
$this->ort[$m] -= $g;
|
||||
// Apply Householder similarity transformation
|
||||
// H = (I-u*u'/h)*H*(I-u*u')/h)
|
||||
for ($j = $m; $j < $this->n; $j++) {
|
||||
$f = 0.0;
|
||||
for ($i = $high; $i >= $m; $i--)
|
||||
$f += $this->ort[$i] * $this->H[$i][$j];
|
||||
$f /= $h;
|
||||
for ($i = $m; $i <= $high; $i++)
|
||||
$this->H[$i][$j] -= $f * $this->ort[$i];
|
||||
}
|
||||
for ($i = 0; $i <= $high; $i++) {
|
||||
$f = 0.0;
|
||||
for ($j = $high; $j >= $m; $j--)
|
||||
$f += $this->ort[$j] * $this->H[$i][$j];
|
||||
$f = $f/$h;
|
||||
for ($j = $m; $j <= $high; $j++)
|
||||
$this->H[$i][$j] -= $f * $this->ort[$j];
|
||||
}
|
||||
$this->ort[$m] = $scale * $this->ort[$m];
|
||||
$this->H[$m][$m-1] = $scale * $g;
|
||||
}
|
||||
}
|
||||
// Accumulate transformations (Algol's ortran).
|
||||
for ($i = 0; $i < $this->n; $i++)
|
||||
for ($j = 0; $j < $this->n; $j++)
|
||||
$this->V[$i][$j] = ($i == $j ? 1.0 : 0.0);
|
||||
for ($m = $high-1; $m >= $low+1; $m--) {
|
||||
if ($this->H[$m][$m-1] != 0.0) {
|
||||
for ($i = $m+1; $i <= $high; $i++)
|
||||
$this->ort[$i] = $this->H[$i][$m-1];
|
||||
for ($j = $m; $j <= $high; $j++) {
|
||||
$g = 0.0;
|
||||
for ($i = $m; $i <= $high; $i++)
|
||||
$g += $this->ort[$i] * $this->V[$i][$j];
|
||||
// Double division avoids possible underflow
|
||||
$g = ($g / $this->ort[$m]) / $this->H[$m][$m-1];
|
||||
for ($i = $m; $i <= $high; $i++)
|
||||
$this->V[$i][$j] += $g * $this->ort[$i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs complex division.
|
||||
* @access private
|
||||
*/
|
||||
function cdiv($xr, $xi, $yr, $yi) {
|
||||
if (abs($yr) > abs($yi)) {
|
||||
$r = $yi / $yr;
|
||||
$d = $yr + $r * $yi;
|
||||
$this->cdivr = ($xr + $r * $xi) / $d;
|
||||
$this->cdivi = ($xi - $r * $xr) / $d;
|
||||
} else {
|
||||
$r = $yr / $yi;
|
||||
$d = $yi + $r * $yr;
|
||||
$this->cdivr = ($r * $xr + $xi) / $d;
|
||||
$this->cdivi = ($r * $xi - $xr) / $d;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Nonsymmetric reduction from Hessenberg to real Schur form.
|
||||
*
|
||||
* Code is derived from the Algol procedure hqr2,
|
||||
* by Martin and Wilkinson, Handbook for Auto. Comp.,
|
||||
* Vol.ii-Linear Algebra, and the corresponding
|
||||
* Fortran subroutine in EISPACK.
|
||||
*
|
||||
* @access private
|
||||
*/
|
||||
function hqr2 () {
|
||||
// Initialize
|
||||
$nn = $this->n;
|
||||
$n = $nn - 1;
|
||||
$low = 0;
|
||||
$high = $nn - 1;
|
||||
$eps = pow(2.0, -52.0);
|
||||
$exshift = 0.0;
|
||||
$p = $q = $r = $s = $z = 0;
|
||||
// Store roots isolated by balanc and compute matrix norm
|
||||
$norm = 0.0;
|
||||
for ($i = 0; $i < $nn; $i++) {
|
||||
if (($i < $low) OR ($i > $high)) {
|
||||
$this->d[$i] = $this->H[$i][$i];
|
||||
$this->e[$i] = 0.0;
|
||||
}
|
||||
for ($j = max($i-1, 0); $j < $nn; $j++)
|
||||
$norm = $norm + abs($this->H[$i][$j]);
|
||||
}
|
||||
// Outer loop over eigenvalue index
|
||||
$iter = 0;
|
||||
while ($n >= $low) {
|
||||
// Look for single small sub-diagonal element
|
||||
$l = $n;
|
||||
while ($l > $low) {
|
||||
$s = abs($this->H[$l-1][$l-1]) + abs($this->H[$l][$l]);
|
||||
if ($s == 0.0)
|
||||
$s = $norm;
|
||||
if (abs($this->H[$l][$l-1]) < $eps * $s)
|
||||
break;
|
||||
$l--;
|
||||
}
|
||||
// Check for convergence
|
||||
// One root found
|
||||
if ($l == $n) {
|
||||
$this->H[$n][$n] = $this->H[$n][$n] + $exshift;
|
||||
$this->d[$n] = $this->H[$n][$n];
|
||||
$this->e[$n] = 0.0;
|
||||
$n--;
|
||||
$iter = 0;
|
||||
// Two roots found
|
||||
} else if ($l == $n-1) {
|
||||
$w = $this->H[$n][$n-1] * $this->H[$n-1][$n];
|
||||
$p = ($this->H[$n-1][$n-1] - $this->H[$n][$n]) / 2.0;
|
||||
$q = $p * $p + $w;
|
||||
$z = sqrt(abs($q));
|
||||
$this->H[$n][$n] = $this->H[$n][$n] + $exshift;
|
||||
$this->H[$n-1][$n-1] = $this->H[$n-1][$n-1] + $exshift;
|
||||
$x = $this->H[$n][$n];
|
||||
// Real pair
|
||||
if ($q >= 0) {
|
||||
if ($p >= 0)
|
||||
$z = $p + $z;
|
||||
else
|
||||
$z = $p - $z;
|
||||
$this->d[$n-1] = $x + $z;
|
||||
$this->d[$n] = $this->d[$n-1];
|
||||
if ($z != 0.0)
|
||||
$this->d[$n] = $x - $w / $z;
|
||||
$this->e[$n-1] = 0.0;
|
||||
$this->e[$n] = 0.0;
|
||||
$x = $this->H[$n][$n-1];
|
||||
$s = abs($x) + abs($z);
|
||||
$p = $x / $s;
|
||||
$q = $z / $s;
|
||||
$r = sqrt($p * $p + $q * $q);
|
||||
$p = $p / $r;
|
||||
$q = $q / $r;
|
||||
// Row modification
|
||||
for ($j = $n-1; $j < $nn; $j++) {
|
||||
$z = $this->H[$n-1][$j];
|
||||
$this->H[$n-1][$j] = $q * $z + $p * $this->H[$n][$j];
|
||||
$this->H[$n][$j] = $q * $this->H[$n][$j] - $p * $z;
|
||||
}
|
||||
// Column modification
|
||||
for ($i = 0; $i <= n; $i++) {
|
||||
$z = $this->H[$i][$n-1];
|
||||
$this->H[$i][$n-1] = $q * $z + $p * $this->H[$i][$n];
|
||||
$this->H[$i][$n] = $q * $this->H[$i][$n] - $p * $z;
|
||||
}
|
||||
// Accumulate transformations
|
||||
for ($i = $low; $i <= $high; $i++) {
|
||||
$z = $this->V[$i][$n-1];
|
||||
$this->V[$i][$n-1] = $q * $z + $p * $this->V[$i][$n];
|
||||
$this->V[$i][$n] = $q * $this->V[$i][$n] - $p * $z;
|
||||
}
|
||||
// Complex pair
|
||||
} else {
|
||||
$this->d[$n-1] = $x + $p;
|
||||
$this->d[$n] = $x + $p;
|
||||
$this->e[$n-1] = $z;
|
||||
$this->e[$n] = -$z;
|
||||
}
|
||||
$n = $n - 2;
|
||||
$iter = 0;
|
||||
// No convergence yet
|
||||
} else {
|
||||
// Form shift
|
||||
$x = $this->H[$n][$n];
|
||||
$y = 0.0;
|
||||
$w = 0.0;
|
||||
if ($l < $n) {
|
||||
$y = $this->H[$n-1][$n-1];
|
||||
$w = $this->H[$n][$n-1] * $this->H[$n-1][$n];
|
||||
}
|
||||
// Wilkinson's original ad hoc shift
|
||||
if ($iter == 10) {
|
||||
$exshift += $x;
|
||||
for ($i = $low; $i <= $n; $i++)
|
||||
$this->H[$i][$i] -= $x;
|
||||
$s = abs($this->H[$n][$n-1]) + abs($this->H[$n-1][$n-2]);
|
||||
$x = $y = 0.75 * $s;
|
||||
$w = -0.4375 * $s * $s;
|
||||
}
|
||||
// MATLAB's new ad hoc shift
|
||||
if ($iter == 30) {
|
||||
$s = ($y - $x) / 2.0;
|
||||
$s = $s * $s + $w;
|
||||
if ($s > 0) {
|
||||
$s = sqrt($s);
|
||||
if ($y < $x)
|
||||
$s = -$s;
|
||||
$s = $x - $w / (($y - $x) / 2.0 + $s);
|
||||
for ($i = $low; $i <= $n; $i++)
|
||||
$this->H[$i][$i] -= $s;
|
||||
$exshift += $s;
|
||||
$x = $y = $w = 0.964;
|
||||
}
|
||||
}
|
||||
// Could check iteration count here.
|
||||
$iter = $iter + 1;
|
||||
// Look for two consecutive small sub-diagonal elements
|
||||
$m = $n - 2;
|
||||
while ($m >= $l) {
|
||||
$z = $this->H[$m][$m];
|
||||
$r = $x - $z;
|
||||
$s = $y - $z;
|
||||
$p = ($r * $s - $w) / $this->H[$m+1][$m] + $this->H[$m][$m+1];
|
||||
$q = $this->H[$m+1][$m+1] - $z - $r - $s;
|
||||
$r = $this->H[$m+2][$m+1];
|
||||
$s = abs($p) + abs($q) + abs($r);
|
||||
$p = $p / $s;
|
||||
$q = $q / $s;
|
||||
$r = $r / $s;
|
||||
if ($m == $l)
|
||||
break;
|
||||
if (abs($this->H[$m][$m-1]) * (abs($q) + abs($r)) < $eps * (abs($p) * (abs($this->H[$m-1][$m-1]) + abs($z) + abs($this->H[$m+1][$m+1]))))
|
||||
break;
|
||||
$m--;
|
||||
}
|
||||
for ($i = $m + 2; $i <= $n; $i++) {
|
||||
$this->H[$i][$i-2] = 0.0;
|
||||
if ($i > $m+2)
|
||||
$this->H[$i][$i-3] = 0.0;
|
||||
}
|
||||
// Double QR step involving rows l:n and columns m:n
|
||||
for ($k = $m; $k <= $n-1; $k++) {
|
||||
$notlast = ($k != $n-1);
|
||||
if ($k != $m) {
|
||||
$p = $this->H[$k][$k-1];
|
||||
$q = $this->H[$k+1][$k-1];
|
||||
$r = ($notlast ? $this->H[$k+2][$k-1] : 0.0);
|
||||
$x = abs($p) + abs($q) + abs($r);
|
||||
if ($x != 0.0) {
|
||||
$p = $p / $x;
|
||||
$q = $q / $x;
|
||||
$r = $r / $x;
|
||||
}
|
||||
}
|
||||
if ($x == 0.0)
|
||||
break;
|
||||
$s = sqrt($p * $p + $q * $q + $r * $r);
|
||||
if ($p < 0)
|
||||
$s = -$s;
|
||||
if ($s != 0) {
|
||||
if ($k != $m)
|
||||
$this->H[$k][$k-1] = -$s * $x;
|
||||
else if ($l != $m)
|
||||
$this->H[$k][$k-1] = -$this->H[$k][$k-1];
|
||||
$p = $p + $s;
|
||||
$x = $p / $s;
|
||||
$y = $q / $s;
|
||||
$z = $r / $s;
|
||||
$q = $q / $p;
|
||||
$r = $r / $p;
|
||||
// Row modification
|
||||
for ($j = $k; $j < $nn; $j++) {
|
||||
$p = $this->H[$k][$j] + $q * $this->H[$k+1][$j];
|
||||
if ($notlast) {
|
||||
$p = $p + $r * $this->H[$k+2][$j];
|
||||
$this->H[$k+2][$j] = $this->H[$k+2][$j] - $p * $z;
|
||||
}
|
||||
$this->H[$k][$j] = $this->H[$k][$j] - $p * $x;
|
||||
$this->H[$k+1][$j] = $this->H[$k+1][$j] - $p * $y;
|
||||
}
|
||||
// Column modification
|
||||
for ($i = 0; $i <= min($n, $k+3); $i++) {
|
||||
$p = $x * $this->H[$i][$k] + $y * $this->H[$i][$k+1];
|
||||
if ($notlast) {
|
||||
$p = $p + $z * $this->H[$i][$k+2];
|
||||
$this->H[$i][$k+2] = $this->H[$i][$k+2] - $p * $r;
|
||||
}
|
||||
$this->H[$i][$k] = $this->H[$i][$k] - $p;
|
||||
$this->H[$i][$k+1] = $this->H[$i][$k+1] - $p * $q;
|
||||
}
|
||||
// Accumulate transformations
|
||||
for ($i = $low; $i <= $high; $i++) {
|
||||
$p = $x * $this->V[$i][$k] + $y * $this->V[$i][$k+1];
|
||||
if ($notlast) {
|
||||
$p = $p + $z * $this->V[$i][$k+2];
|
||||
$this->V[$i][$k+2] = $this->V[$i][$k+2] - $p * $r;
|
||||
}
|
||||
$this->V[$i][$k] = $this->V[$i][$k] - $p;
|
||||
$this->V[$i][$k+1] = $this->V[$i][$k+1] - $p * $q;
|
||||
}
|
||||
} // ($s != 0)
|
||||
} // k loop
|
||||
} // check convergence
|
||||
} // while ($n >= $low)
|
||||
// Backsubstitute to find vectors of upper triangular form
|
||||
if ($norm == 0.0)
|
||||
return;
|
||||
for ($n = $nn-1; $n >= 0; $n--) {
|
||||
$p = $this->d[$n];
|
||||
$q = $this->e[$n];
|
||||
// Real vector
|
||||
if ($q == 0) {
|
||||
$l = $n;
|
||||
$this->H[$n][$n] = 1.0;
|
||||
for ($i = $n-1; $i >= 0; $i--) {
|
||||
$w = $this->H[$i][$i] - $p;
|
||||
$r = 0.0;
|
||||
for ($j = $l; $j <= $n; $j++)
|
||||
$r = $r + $this->H[$i][$j] * $this->H[$j][$n];
|
||||
if ($this->e[$i] < 0.0) {
|
||||
$z = $w;
|
||||
$s = $r;
|
||||
} else {
|
||||
$l = $i;
|
||||
if ($this->e[$i] == 0.0) {
|
||||
if ($w != 0.0)
|
||||
$this->H[$i][$n] = -$r / $w;
|
||||
else
|
||||
$this->H[$i][$n] = -$r / ($eps * $norm);
|
||||
// Solve real equations
|
||||
} else {
|
||||
$x = $this->H[$i][$i+1];
|
||||
$y = $this->H[$i+1][$i];
|
||||
$q = ($this->d[$i] - $p) * ($this->d[$i] - $p) + $this->e[$i] * $this->e[$i];
|
||||
$t = ($x * $s - $z * $r) / $q;
|
||||
$this->H[$i][$n] = $t;
|
||||
if (abs($x) > abs($z))
|
||||
$this->H[$i+1][$n] = (-$r - $w * $t) / $x;
|
||||
else
|
||||
$this->H[$i+1][$n] = (-$s - $y * $t) / $z;
|
||||
}
|
||||
// Overflow control
|
||||
$t = abs($this->H[$i][$n]);
|
||||
if (($eps * $t) * $t > 1) {
|
||||
for ($j = $i; $j <= $n; $j++)
|
||||
$this->H[$j][$n] = $this->H[$j][$n] / $t;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Complex vector
|
||||
} else if ($q < 0) {
|
||||
$l = $n-1;
|
||||
// Last vector component imaginary so matrix is triangular
|
||||
if (abs($this->H[$n][$n-1]) > abs($this->H[$n-1][$n])) {
|
||||
$this->H[$n-1][$n-1] = $q / $this->H[$n][$n-1];
|
||||
$this->H[$n-1][$n] = -($this->H[$n][$n] - $p) / $this->H[$n][$n-1];
|
||||
} else {
|
||||
$this->cdiv(0.0, -$this->H[$n-1][$n], $this->H[$n-1][$n-1] - $p, $q);
|
||||
$this->H[$n-1][$n-1] = $this->cdivr;
|
||||
$this->H[$n-1][$n] = $this->cdivi;
|
||||
}
|
||||
$this->H[$n][$n-1] = 0.0;
|
||||
$this->H[$n][$n] = 1.0;
|
||||
for ($i = $n-2; $i >= 0; $i--) {
|
||||
// double ra,sa,vr,vi;
|
||||
$ra = 0.0;
|
||||
$sa = 0.0;
|
||||
for ($j = $l; $j <= $n; $j++) {
|
||||
$ra = $ra + $this->H[$i][$j] * $this->H[$j][$n-1];
|
||||
$sa = $sa + $this->H[$i][$j] * $this->H[$j][$n];
|
||||
}
|
||||
$w = $this->H[$i][$i] - $p;
|
||||
if ($this->e[$i] < 0.0) {
|
||||
$z = $w;
|
||||
$r = $ra;
|
||||
$s = $sa;
|
||||
} else {
|
||||
$l = $i;
|
||||
if ($this->e[$i] == 0) {
|
||||
$this->cdiv(-$ra, -$sa, $w, $q);
|
||||
$this->H[$i][$n-1] = $this->cdivr;
|
||||
$this->H[$i][$n] = $this->cdivi;
|
||||
} else {
|
||||
// Solve complex equations
|
||||
$x = $this->H[$i][$i+1];
|
||||
$y = $this->H[$i+1][$i];
|
||||
$vr = ($this->d[$i] - $p) * ($this->d[$i] - $p) + $this->e[$i] * $this->e[$i] - $q * $q;
|
||||
$vi = ($this->d[$i] - $p) * 2.0 * $q;
|
||||
if ($vr == 0.0 & $vi == 0.0)
|
||||
$vr = $eps * $norm * (abs($w) + abs($q) + abs($x) + abs($y) + abs($z));
|
||||
$this->cdiv($x * $r - $z * $ra + $q * $sa, $x * $s - $z * $sa - $q * $ra, $vr, $vi);
|
||||
$this->H[$i][$n-1] = $this->cdivr;
|
||||
$this->H[$i][$n] = $this->cdivi;
|
||||
if (abs($x) > (abs($z) + abs($q))) {
|
||||
$this->H[$i+1][$n-1] = (-$ra - $w * $this->H[$i][$n-1] + $q * $this->H[$i][$n]) / $x;
|
||||
$this->H[$i+1][$n] = (-$sa - $w * $this->H[$i][$n] - $q * $this->H[$i][$n-1]) / $x;
|
||||
} else {
|
||||
$this->cdiv(-$r - $y * $this->H[$i][$n-1], -$s - $y * $this->H[$i][$n], $z, $q);
|
||||
$this->H[$i+1][$n-1] = $this->cdivr;
|
||||
$this->H[$i+1][$n] = $this->cdivi;
|
||||
}
|
||||
}
|
||||
// Overflow control
|
||||
$t = max(abs($this->H[$i][$n-1]),abs($this->H[$i][$n]));
|
||||
if (($eps * $t) * $t > 1) {
|
||||
for ($j = $i; $j <= $n; $j++) {
|
||||
$this->H[$j][$n-1] = $this->H[$j][$n-1] / $t;
|
||||
$this->H[$j][$n] = $this->H[$j][$n] / $t;
|
||||
}
|
||||
}
|
||||
} // end else
|
||||
} // end for
|
||||
} // end else for complex case
|
||||
} // end for
|
||||
// Vectors of isolated roots
|
||||
for ($i = 0; $i < $nn; $i++) {
|
||||
if ($i < $low | $i > $high) {
|
||||
for ($j = $i; $j < $nn; $j++)
|
||||
$this->V[$i][$j] = $this->H[$i][$j];
|
||||
}
|
||||
}
|
||||
// Back transformation to get eigenvectors of original matrix
|
||||
for ($j = $nn-1; $j >= $low; $j--) {
|
||||
for ($i = $low; $i <= $high; $i++) {
|
||||
$z = 0.0;
|
||||
for ($k = $low; $k <= min($j,$high); $k++)
|
||||
$z = $z + $this->V[$i][$k] * $this->H[$k][$j];
|
||||
$this->V[$i][$j] = $z;
|
||||
}
|
||||
}
|
||||
} // end hqr2
|
||||
|
||||
/**
|
||||
* Constructor: Check for symmetry, then construct the eigenvalue decomposition
|
||||
* @access public
|
||||
* @param A Square matrix
|
||||
* @return Structure to access D and V.
|
||||
*/
|
||||
function EigenvalueDecomposition($Arg) {
|
||||
$this->A = $Arg->getArray();
|
||||
$this->n = $Arg->getColumnDimension();
|
||||
$this->V = array();
|
||||
$this->d = array();
|
||||
$this->e = array();
|
||||
$issymmetric = true;
|
||||
for ($j = 0; ($j < $this->n) & $issymmetric; $j++)
|
||||
for ($i = 0; ($i < $this->n) & $issymmetric; $i++)
|
||||
$issymmetric = ($this->A[$i][$j] == $this->A[$j][$i]);
|
||||
if ($issymmetric) {
|
||||
$this->V = $this->A;
|
||||
// Tridiagonalize.
|
||||
$this->tred2();
|
||||
// Diagonalize.
|
||||
$this->tql2();
|
||||
} else {
|
||||
$this->H = $this->A;
|
||||
$this->ort = array();
|
||||
// Reduce to Hessenberg form.
|
||||
$this->orthes();
|
||||
// Reduce Hessenberg to real Schur form.
|
||||
$this->hqr2();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the eigenvector matrix
|
||||
* @access public
|
||||
* @return V
|
||||
*/
|
||||
function getV() {
|
||||
return new Matrix($this->V, $this->n, $this->n);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the real parts of the eigenvalues
|
||||
* @access public
|
||||
* @return real(diag(D))
|
||||
*/
|
||||
function getRealEigenvalues() {
|
||||
return $this->d;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the imaginary parts of the eigenvalues
|
||||
* @access public
|
||||
* @return imag(diag(D))
|
||||
*/
|
||||
function getImagEigenvalues() {
|
||||
return $this->e;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the block diagonal eigenvalue matrix
|
||||
* @access public
|
||||
* @return D
|
||||
*/
|
||||
function getD() {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
$D[$i] = array_fill(0, $this->n, 0.0);
|
||||
$D[$i][$i] = $this->d[$i];
|
||||
if ($this->e[$i] == 0)
|
||||
continue;
|
||||
$o = ($this->e[$i] > 0) ? $i + 1 : $i - 1;
|
||||
$D[$i][$o] = $this->e[$i];
|
||||
}
|
||||
return new Matrix($D);
|
||||
}
|
||||
}
|
||||
222
include/PHPExcel/PHPExcel/Shared/JAMA/LUDecomposition.php
Executable file
222
include/PHPExcel/PHPExcel/Shared/JAMA/LUDecomposition.php
Executable file
@@ -0,0 +1,222 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* For an m-by-n matrix A with m >= n, the LU decomposition is an m-by-n
|
||||
* unit lower triangular matrix L, an n-by-n upper triangular matrix U,
|
||||
* and a permutation vector piv of length m so that A(piv,:) = L*U.
|
||||
* If m < n, then L is m-by-m and U is m-by-n.
|
||||
*
|
||||
* The LU decompostion with pivoting always exists, even if the matrix is
|
||||
* singular, so the constructor will never fail. The primary use of the
|
||||
* LU decomposition is in the solution of square systems of simultaneous
|
||||
* linear equations. This will fail if isNonsingular() returns false.
|
||||
*
|
||||
* @author Paul Meagher
|
||||
* @author Bartosz Matosiuk
|
||||
* @author Michael Bommarito
|
||||
* @version 1.1
|
||||
* @license PHP v3.0
|
||||
*/
|
||||
class LUDecomposition {
|
||||
/**
|
||||
* Decomposition storage
|
||||
* @var array
|
||||
*/
|
||||
var $LU = array();
|
||||
|
||||
/**
|
||||
* Row dimension.
|
||||
* @var int
|
||||
*/
|
||||
var $m;
|
||||
|
||||
/**
|
||||
* Column dimension.
|
||||
* @var int
|
||||
*/
|
||||
var $n;
|
||||
|
||||
/**
|
||||
* Pivot sign.
|
||||
* @var int
|
||||
*/
|
||||
var $pivsign;
|
||||
|
||||
/**
|
||||
* Internal storage of pivot vector.
|
||||
* @var array
|
||||
*/
|
||||
var $piv = array();
|
||||
|
||||
/**
|
||||
* LU Decomposition constructor.
|
||||
* @param $A Rectangular matrix
|
||||
* @return Structure to access L, U and piv.
|
||||
*/
|
||||
function LUDecomposition ($A) {
|
||||
if( is_a($A, 'Matrix') ) {
|
||||
// Use a "left-looking", dot-product, Crout/Doolittle algorithm.
|
||||
$this->LU = $A->getArrayCopy();
|
||||
$this->m = $A->getRowDimension();
|
||||
$this->n = $A->getColumnDimension();
|
||||
for ($i = 0; $i < $this->m; $i++)
|
||||
$this->piv[$i] = $i;
|
||||
$this->pivsign = 1;
|
||||
$LUrowi = array();
|
||||
$LUcolj = array();
|
||||
// Outer loop.
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
// Make a copy of the j-th column to localize references.
|
||||
for ($i = 0; $i < $this->m; $i++)
|
||||
$LUcolj[$i] = &$this->LU[$i][$j];
|
||||
// Apply previous transformations.
|
||||
for ($i = 0; $i < $this->m; $i++) {
|
||||
$LUrowi = $this->LU[$i];
|
||||
// Most of the time is spent in the following dot product.
|
||||
$kmax = min($i,$j);
|
||||
$s = 0.0;
|
||||
for ($k = 0; $k < $kmax; $k++)
|
||||
$s += $LUrowi[$k]*$LUcolj[$k];
|
||||
$LUrowi[$j] = $LUcolj[$i] -= $s;
|
||||
}
|
||||
// Find pivot and exchange if necessary.
|
||||
$p = $j;
|
||||
for ($i = $j+1; $i < $this->m; $i++) {
|
||||
if (abs($LUcolj[$i]) > abs($LUcolj[$p]))
|
||||
$p = $i;
|
||||
}
|
||||
if ($p != $j) {
|
||||
for ($k = 0; $k < $this->n; $k++) {
|
||||
$t = $this->LU[$p][$k];
|
||||
$this->LU[$p][$k] = $this->LU[$j][$k];
|
||||
$this->LU[$j][$k] = $t;
|
||||
}
|
||||
$k = $this->piv[$p];
|
||||
$this->piv[$p] = $this->piv[$j];
|
||||
$this->piv[$j] = $k;
|
||||
$this->pivsign = $this->pivsign * -1;
|
||||
}
|
||||
// Compute multipliers.
|
||||
if ( ($j < $this->m) AND ($this->LU[$j][$j] != 0.0) ) {
|
||||
for ($i = $j+1; $i < $this->m; $i++)
|
||||
$this->LU[$i][$j] /= $this->LU[$j][$j];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
trigger_error(ArgumentTypeException, ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get lower triangular factor.
|
||||
* @return array Lower triangular factor
|
||||
*/
|
||||
function getL () {
|
||||
for ($i = 0; $i < $this->m; $i++) {
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
if ($i > $j)
|
||||
$L[$i][$j] = $this->LU[$i][$j];
|
||||
else if($i == $j)
|
||||
$L[$i][$j] = 1.0;
|
||||
else
|
||||
$L[$i][$j] = 0.0;
|
||||
}
|
||||
}
|
||||
return new Matrix($L);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get upper triangular factor.
|
||||
* @return array Upper triangular factor
|
||||
*/
|
||||
function getU () {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
if ($i <= $j)
|
||||
$U[$i][$j] = $this->LU[$i][$j];
|
||||
else
|
||||
$U[$i][$j] = 0.0;
|
||||
}
|
||||
}
|
||||
return new Matrix($U);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return pivot permutation vector.
|
||||
* @return array Pivot vector
|
||||
*/
|
||||
function getPivot () {
|
||||
return $this->piv;
|
||||
}
|
||||
|
||||
/**
|
||||
* Alias for getPivot
|
||||
* @see getPivot
|
||||
*/
|
||||
function getDoublePivot () {
|
||||
return $this->getPivot();
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the matrix nonsingular?
|
||||
* @return true if U, and hence A, is nonsingular.
|
||||
*/
|
||||
function isNonsingular () {
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
if ($this->LU[$j][$j] == 0)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Count determinants
|
||||
* @return array d matrix deterninat
|
||||
*/
|
||||
function det() {
|
||||
if ($this->m == $this->n) {
|
||||
$d = $this->pivsign;
|
||||
for ($j = 0; $j < $this->n; $j++)
|
||||
$d *= $this->LU[$j][$j];
|
||||
return $d;
|
||||
} else {
|
||||
trigger_error(MatrixDimensionException, ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Solve A*X = B
|
||||
* @param $B A Matrix with as many rows as A and any number of columns.
|
||||
* @return X so that L*U*X = B(piv,:)
|
||||
* @exception IllegalArgumentException Matrix row dimensions must agree.
|
||||
* @exception RuntimeException Matrix is singular.
|
||||
*/
|
||||
function solve($B) {
|
||||
if ($B->getRowDimension() == $this->m) {
|
||||
if ($this->isNonsingular()) {
|
||||
// Copy right hand side with pivoting
|
||||
$nx = $B->getColumnDimension();
|
||||
$X = $B->getMatrix($this->piv, 0, $nx-1);
|
||||
// Solve L*Y = B(piv,:)
|
||||
for ($k = 0; $k < $this->n; $k++)
|
||||
for ($i = $k+1; $i < $this->n; $i++)
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X->A[$i][$j] -= $X->A[$k][$j] * $this->LU[$i][$k];
|
||||
// Solve U*X = Y;
|
||||
for ($k = $this->n-1; $k >= 0; $k--) {
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X->A[$k][$j] /= $this->LU[$k][$k];
|
||||
for ($i = 0; $i < $k; $i++)
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X->A[$i][$j] -= $X->A[$k][$j] * $this->LU[$i][$k];
|
||||
}
|
||||
return $X;
|
||||
} else {
|
||||
trigger_error(MatrixSingularException, ERROR);
|
||||
}
|
||||
} else {
|
||||
trigger_error(MatrixSquareException, ERROR);
|
||||
}
|
||||
}
|
||||
}
|
||||
1331
include/PHPExcel/PHPExcel/Shared/JAMA/Matrix.php
Executable file
1331
include/PHPExcel/PHPExcel/Shared/JAMA/Matrix.php
Executable file
File diff suppressed because it is too large
Load Diff
195
include/PHPExcel/PHPExcel/Shared/JAMA/QRDecomposition.php
Executable file
195
include/PHPExcel/PHPExcel/Shared/JAMA/QRDecomposition.php
Executable file
@@ -0,0 +1,195 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* For an m-by-n matrix A with m >= n, the QR decomposition is an m-by-n
|
||||
* orthogonal matrix Q and an n-by-n upper triangular matrix R so that
|
||||
* A = Q*R.
|
||||
*
|
||||
* The QR decompostion always exists, even if the matrix does not have
|
||||
* full rank, so the constructor will never fail. The primary use of the
|
||||
* QR decomposition is in the least squares solution of nonsquare systems
|
||||
* of simultaneous linear equations. This will fail if isFullRank()
|
||||
* returns false.
|
||||
*
|
||||
* @author Paul Meagher
|
||||
* @license PHP v3.0
|
||||
* @version 1.1
|
||||
*/
|
||||
class QRDecomposition {
|
||||
/**
|
||||
* Array for internal storage of decomposition.
|
||||
* @var array
|
||||
*/
|
||||
var $QR = array();
|
||||
|
||||
/**
|
||||
* Row dimension.
|
||||
* @var integer
|
||||
*/
|
||||
var $m;
|
||||
|
||||
/**
|
||||
* Column dimension.
|
||||
* @var integer
|
||||
*/
|
||||
var $n;
|
||||
|
||||
/**
|
||||
* Array for internal storage of diagonal of R.
|
||||
* @var array
|
||||
*/
|
||||
var $Rdiag = array();
|
||||
|
||||
/**
|
||||
* QR Decomposition computed by Householder reflections.
|
||||
* @param matrix $A Rectangular matrix
|
||||
* @return Structure to access R and the Householder vectors and compute Q.
|
||||
*/
|
||||
function QRDecomposition($A) {
|
||||
if( is_a($A, 'Matrix') ) {
|
||||
// Initialize.
|
||||
$this->QR = $A->getArrayCopy();
|
||||
$this->m = $A->getRowDimension();
|
||||
$this->n = $A->getColumnDimension();
|
||||
// Main loop.
|
||||
for ($k = 0; $k < $this->n; $k++) {
|
||||
// Compute 2-norm of k-th column without under/overflow.
|
||||
$nrm = 0.0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$nrm = hypo($nrm, $this->QR[$i][$k]);
|
||||
if ($nrm != 0.0) {
|
||||
// Form k-th Householder vector.
|
||||
if ($this->QR[$k][$k] < 0)
|
||||
$nrm = -$nrm;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$this->QR[$i][$k] /= $nrm;
|
||||
$this->QR[$k][$k] += 1.0;
|
||||
// Apply transformation to remaining columns.
|
||||
for ($j = $k+1; $j < $this->n; $j++) {
|
||||
$s = 0.0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$s += $this->QR[$i][$k] * $this->QR[$i][$j];
|
||||
$s = -$s/$this->QR[$k][$k];
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$this->QR[$i][$j] += $s * $this->QR[$i][$k];
|
||||
}
|
||||
}
|
||||
$this->Rdiag[$k] = -$nrm;
|
||||
}
|
||||
} else
|
||||
trigger_error(ArgumentTypeException, ERROR);
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the matrix full rank?
|
||||
* @return boolean true if R, and hence A, has full rank, else false.
|
||||
*/
|
||||
function isFullRank() {
|
||||
for ($j = 0; $j < $this->n; $j++)
|
||||
if ($this->Rdiag[$j] == 0)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the Householder vectors
|
||||
* @return Matrix Lower trapezoidal matrix whose columns define the reflections
|
||||
*/
|
||||
function getH() {
|
||||
for ($i = 0; $i < $this->m; $i++) {
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
if ($i >= $j)
|
||||
$H[$i][$j] = $this->QR[$i][$j];
|
||||
else
|
||||
$H[$i][$j] = 0.0;
|
||||
}
|
||||
}
|
||||
return new Matrix($H);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the upper triangular factor
|
||||
* @return Matrix upper triangular factor
|
||||
*/
|
||||
function getR() {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
for ($j = 0; $j < $this->n; $j++) {
|
||||
if ($i < $j)
|
||||
$R[$i][$j] = $this->QR[$i][$j];
|
||||
else if ($i == $j)
|
||||
$R[$i][$j] = $this->Rdiag[$i];
|
||||
else
|
||||
$R[$i][$j] = 0.0;
|
||||
}
|
||||
}
|
||||
return new Matrix($R);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate and return the (economy-sized) orthogonal factor
|
||||
* @return Matrix orthogonal factor
|
||||
*/
|
||||
function getQ() {
|
||||
for ($k = $this->n-1; $k >= 0; $k--) {
|
||||
for ($i = 0; $i < $this->m; $i++)
|
||||
$Q[$i][$k] = 0.0;
|
||||
$Q[$k][$k] = 1.0;
|
||||
for ($j = $k; $j < $this->n; $j++) {
|
||||
if ($this->QR[$k][$k] != 0) {
|
||||
$s = 0.0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$s += $this->QR[$i][$k] * $Q[$i][$j];
|
||||
$s = -$s/$this->QR[$k][$k];
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$Q[$i][$j] += $s * $this->QR[$i][$k];
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
for( $i = 0; $i < count($Q); $i++ )
|
||||
for( $j = 0; $j < count($Q); $j++ )
|
||||
if(! isset($Q[$i][$j]) )
|
||||
$Q[$i][$j] = 0;
|
||||
*/
|
||||
return new Matrix($Q);
|
||||
}
|
||||
|
||||
/**
|
||||
* Least squares solution of A*X = B
|
||||
* @param Matrix $B A Matrix with as many rows as A and any number of columns.
|
||||
* @return Matrix Matrix that minimizes the two norm of Q*R*X-B.
|
||||
*/
|
||||
function solve($B) {
|
||||
if ($B->getRowDimension() == $this->m) {
|
||||
if ($this->isFullRank()) {
|
||||
// Copy right hand side
|
||||
$nx = $B->getColumnDimension();
|
||||
$X = $B->getArrayCopy();
|
||||
// Compute Y = transpose(Q)*B
|
||||
for ($k = 0; $k < $this->n; $k++) {
|
||||
for ($j = 0; $j < $nx; $j++) {
|
||||
$s = 0.0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$s += $this->QR[$i][$k] * $X[$i][$j];
|
||||
$s = -$s/$this->QR[$k][$k];
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$X[$i][$j] += $s * $this->QR[$i][$k];
|
||||
}
|
||||
}
|
||||
// Solve R*X = Y;
|
||||
for ($k = $this->n-1; $k >= 0; $k--) {
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X[$k][$j] /= $this->Rdiag[$k];
|
||||
for ($i = 0; $i < $k; $i++)
|
||||
for ($j = 0; $j < $nx; $j++)
|
||||
$X[$i][$j] -= $X[$k][$j]* $this->QR[$i][$k];
|
||||
}
|
||||
$X = new Matrix($X);
|
||||
return ($X->getMatrix(0, $this->n-1, 0, $nx));
|
||||
} else
|
||||
trigger_error(MatrixRankException, ERROR);
|
||||
} else
|
||||
trigger_error(MatrixDimensionException, ERROR);
|
||||
}
|
||||
}
|
||||
501
include/PHPExcel/PHPExcel/Shared/JAMA/SingularValueDecomposition.php
Executable file
501
include/PHPExcel/PHPExcel/Shared/JAMA/SingularValueDecomposition.php
Executable file
@@ -0,0 +1,501 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* For an m-by-n matrix A with m >= n, the singular value decomposition is
|
||||
* an m-by-n orthogonal matrix U, an n-by-n diagonal matrix S, and
|
||||
* an n-by-n orthogonal matrix V so that A = U*S*V'.
|
||||
*
|
||||
* The singular values, sigma[$k] = S[$k][$k], are ordered so that
|
||||
* sigma[0] >= sigma[1] >= ... >= sigma[n-1].
|
||||
*
|
||||
* The singular value decompostion always exists, so the constructor will
|
||||
* never fail. The matrix condition number and the effective numerical
|
||||
* rank can be computed from this decomposition.
|
||||
*
|
||||
* @author Paul Meagher
|
||||
* @license PHP v3.0
|
||||
* @version 1.1
|
||||
*/
|
||||
class SingularValueDecomposition {
|
||||
|
||||
/**
|
||||
* Internal storage of U.
|
||||
* @var array
|
||||
*/
|
||||
var $U = array();
|
||||
|
||||
/**
|
||||
* Internal storage of V.
|
||||
* @var array
|
||||
*/
|
||||
var $V = array();
|
||||
|
||||
/**
|
||||
* Internal storage of singular values.
|
||||
* @var array
|
||||
*/
|
||||
var $s = array();
|
||||
|
||||
/**
|
||||
* Row dimension.
|
||||
* @var int
|
||||
*/
|
||||
var $m;
|
||||
|
||||
/**
|
||||
* Column dimension.
|
||||
* @var int
|
||||
*/
|
||||
var $n;
|
||||
|
||||
/**
|
||||
* Construct the singular value decomposition
|
||||
*
|
||||
* Derived from LINPACK code.
|
||||
*
|
||||
* @param $A Rectangular matrix
|
||||
* @return Structure to access U, S and V.
|
||||
*/
|
||||
function SingularValueDecomposition ($Arg) {
|
||||
|
||||
// Initialize.
|
||||
|
||||
$A = $Arg->getArrayCopy();
|
||||
$this->m = $Arg->getRowDimension();
|
||||
$this->n = $Arg->getColumnDimension();
|
||||
$nu = min($this->m, $this->n);
|
||||
$e = array();
|
||||
$work = array();
|
||||
$wantu = true;
|
||||
$wantv = true;
|
||||
$nct = min($this->m - 1, $this->n);
|
||||
$nrt = max(0, min($this->n - 2, $this->m));
|
||||
|
||||
// Reduce A to bidiagonal form, storing the diagonal elements
|
||||
// in s and the super-diagonal elements in e.
|
||||
|
||||
for ($k = 0; $k < max($nct,$nrt); $k++) {
|
||||
|
||||
if ($k < $nct) {
|
||||
// Compute the transformation for the k-th column and
|
||||
// place the k-th diagonal in s[$k].
|
||||
// Compute 2-norm of k-th column without under/overflow.
|
||||
$this->s[$k] = 0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$this->s[$k] = hypo($this->s[$k], $A[$i][$k]);
|
||||
if ($this->s[$k] != 0.0) {
|
||||
if ($A[$k][$k] < 0.0)
|
||||
$this->s[$k] = -$this->s[$k];
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$A[$i][$k] /= $this->s[$k];
|
||||
$A[$k][$k] += 1.0;
|
||||
}
|
||||
$this->s[$k] = -$this->s[$k];
|
||||
}
|
||||
|
||||
for ($j = $k + 1; $j < $this->n; $j++) {
|
||||
if (($k < $nct) & ($this->s[$k] != 0.0)) {
|
||||
// Apply the transformation.
|
||||
$t = 0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$t += $A[$i][$k] * $A[$i][$j];
|
||||
$t = -$t / $A[$k][$k];
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$A[$i][$j] += $t * $A[$i][$k];
|
||||
// Place the k-th row of A into e for the
|
||||
// subsequent calculation of the row transformation.
|
||||
$e[$j] = $A[$k][$j];
|
||||
}
|
||||
}
|
||||
|
||||
if ($wantu AND ($k < $nct)) {
|
||||
// Place the transformation in U for subsequent back
|
||||
// multiplication.
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$this->U[$i][$k] = $A[$i][$k];
|
||||
}
|
||||
|
||||
if ($k < $nrt) {
|
||||
// Compute the k-th row transformation and place the
|
||||
// k-th super-diagonal in e[$k].
|
||||
// Compute 2-norm without under/overflow.
|
||||
$e[$k] = 0;
|
||||
for ($i = $k + 1; $i < $this->n; $i++)
|
||||
$e[$k] = hypo($e[$k], $e[$i]);
|
||||
if ($e[$k] != 0.0) {
|
||||
if ($e[$k+1] < 0.0)
|
||||
$e[$k] = -$e[$k];
|
||||
for ($i = $k + 1; $i < $this->n; $i++)
|
||||
$e[$i] /= $e[$k];
|
||||
$e[$k+1] += 1.0;
|
||||
}
|
||||
$e[$k] = -$e[$k];
|
||||
if (($k+1 < $this->m) AND ($e[$k] != 0.0)) {
|
||||
// Apply the transformation.
|
||||
for ($i = $k+1; $i < $this->m; $i++)
|
||||
$work[$i] = 0.0;
|
||||
for ($j = $k+1; $j < $this->n; $j++)
|
||||
for ($i = $k+1; $i < $this->m; $i++)
|
||||
$work[$i] += $e[$j] * $A[$i][$j];
|
||||
for ($j = $k + 1; $j < $this->n; $j++) {
|
||||
$t = -$e[$j] / $e[$k+1];
|
||||
for ($i = $k + 1; $i < $this->m; $i++)
|
||||
$A[$i][$j] += $t * $work[$i];
|
||||
}
|
||||
}
|
||||
if ($wantv) {
|
||||
// Place the transformation in V for subsequent
|
||||
// back multiplication.
|
||||
for ($i = $k + 1; $i < $this->n; $i++)
|
||||
$this->V[$i][$k] = $e[$i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Set up the final bidiagonal matrix or order p.
|
||||
$p = min($this->n, $this->m + 1);
|
||||
if ($nct < $this->n)
|
||||
$this->s[$nct] = $A[$nct][$nct];
|
||||
if ($this->m < $p)
|
||||
$this->s[$p-1] = 0.0;
|
||||
if ($nrt + 1 < $p)
|
||||
$e[$nrt] = $A[$nrt][$p-1];
|
||||
$e[$p-1] = 0.0;
|
||||
// If required, generate U.
|
||||
if ($wantu) {
|
||||
for ($j = $nct; $j < $nu; $j++) {
|
||||
for ($i = 0; $i < $this->m; $i++)
|
||||
$this->U[$i][$j] = 0.0;
|
||||
$this->U[$j][$j] = 1.0;
|
||||
}
|
||||
for ($k = $nct - 1; $k >= 0; $k--) {
|
||||
if ($this->s[$k] != 0.0) {
|
||||
for ($j = $k + 1; $j < $nu; $j++) {
|
||||
$t = 0;
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$t += $this->U[$i][$k] * $this->U[$i][$j];
|
||||
$t = -$t / $this->U[$k][$k];
|
||||
for ($i = $k; $i < $this->m; $i++)
|
||||
$this->U[$i][$j] += $t * $this->U[$i][$k];
|
||||
}
|
||||
for ($i = $k; $i < $this->m; $i++ )
|
||||
$this->U[$i][$k] = -$this->U[$i][$k];
|
||||
$this->U[$k][$k] = 1.0 + $this->U[$k][$k];
|
||||
for ($i = 0; $i < $k - 1; $i++)
|
||||
$this->U[$i][$k] = 0.0;
|
||||
} else {
|
||||
for ($i = 0; $i < $this->m; $i++)
|
||||
$this->U[$i][$k] = 0.0;
|
||||
$this->U[$k][$k] = 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If required, generate V.
|
||||
if ($wantv) {
|
||||
for ($k = $this->n - 1; $k >= 0; $k--) {
|
||||
if (($k < $nrt) AND ($e[$k] != 0.0)) {
|
||||
for ($j = $k + 1; $j < $nu; $j++) {
|
||||
$t = 0;
|
||||
for ($i = $k + 1; $i < $this->n; $i++)
|
||||
$t += $this->V[$i][$k]* $this->V[$i][$j];
|
||||
$t = -$t / $this->V[$k+1][$k];
|
||||
for ($i = $k + 1; $i < $this->n; $i++)
|
||||
$this->V[$i][$j] += $t * $this->V[$i][$k];
|
||||
}
|
||||
}
|
||||
for ($i = 0; $i < $this->n; $i++)
|
||||
$this->V[$i][$k] = 0.0;
|
||||
$this->V[$k][$k] = 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
// Main iteration loop for the singular values.
|
||||
$pp = $p - 1;
|
||||
$iter = 0;
|
||||
$eps = pow(2.0, -52.0);
|
||||
while ($p > 0) {
|
||||
|
||||
// Here is where a test for too many iterations would go.
|
||||
// This section of the program inspects for negligible
|
||||
// elements in the s and e arrays. On completion the
|
||||
// variables kase and k are set as follows:
|
||||
// kase = 1 if s(p) and e[k-1] are negligible and k<p
|
||||
// kase = 2 if s(k) is negligible and k<p
|
||||
// kase = 3 if e[k-1] is negligible, k<p, and
|
||||
// s(k), ..., s(p) are not negligible (qr step).
|
||||
// kase = 4 if e(p-1) is negligible (convergence).
|
||||
|
||||
for ($k = $p - 2; $k >= -1; $k--) {
|
||||
if ($k == -1)
|
||||
break;
|
||||
if (abs($e[$k]) <= $eps * (abs($this->s[$k]) + abs($this->s[$k+1]))) {
|
||||
$e[$k] = 0.0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ($k == $p - 2)
|
||||
$kase = 4;
|
||||
else {
|
||||
for ($ks = $p - 1; $ks >= $k; $ks--) {
|
||||
if ($ks == $k)
|
||||
break;
|
||||
$t = ($ks != $p ? abs($e[$ks]) : 0.) + ($ks != $k + 1 ? abs($e[$ks-1]) : 0.);
|
||||
if (abs($this->s[$ks]) <= $eps * $t) {
|
||||
$this->s[$ks] = 0.0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ($ks == $k)
|
||||
$kase = 3;
|
||||
else if ($ks == $p-1)
|
||||
$kase = 1;
|
||||
else {
|
||||
$kase = 2;
|
||||
$k = $ks;
|
||||
}
|
||||
}
|
||||
$k++;
|
||||
|
||||
// Perform the task indicated by kase.
|
||||
switch ($kase) {
|
||||
// Deflate negligible s(p).
|
||||
case 1:
|
||||
$f = $e[$p-2];
|
||||
$e[$p-2] = 0.0;
|
||||
for ($j = $p - 2; $j >= $k; $j--) {
|
||||
$t = hypo($this->s[$j],$f);
|
||||
$cs = $this->s[$j] / $t;
|
||||
$sn = $f / $t;
|
||||
$this->s[$j] = $t;
|
||||
if ($j != $k) {
|
||||
$f = -$sn * $e[$j-1];
|
||||
$e[$j-1] = $cs * $e[$j-1];
|
||||
}
|
||||
if ($wantv) {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$p-1];
|
||||
$this->V[$i][$p-1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$p-1];
|
||||
$this->V[$i][$j] = $t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
// Split at negligible s(k).
|
||||
case 2:
|
||||
$f = $e[$k-1];
|
||||
$e[$k-1] = 0.0;
|
||||
for ($j = $k; $j < $p; $j++) {
|
||||
$t = hypo($this->s[$j], $f);
|
||||
$cs = $this->s[$j] / $t;
|
||||
$sn = $f / $t;
|
||||
$this->s[$j] = $t;
|
||||
$f = -$sn * $e[$j];
|
||||
$e[$j] = $cs * $e[$j];
|
||||
if ($wantu) {
|
||||
for ($i = 0; $i < $this->m; $i++) {
|
||||
$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$k-1];
|
||||
$this->U[$i][$k-1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$k-1];
|
||||
$this->U[$i][$j] = $t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
// Perform one qr step.
|
||||
case 3:
|
||||
// Calculate the shift.
|
||||
$scale = max(max(max(max(
|
||||
abs($this->s[$p-1]),abs($this->s[$p-2])),abs($e[$p-2])),
|
||||
abs($this->s[$k])), abs($e[$k]));
|
||||
$sp = $this->s[$p-1] / $scale;
|
||||
$spm1 = $this->s[$p-2] / $scale;
|
||||
$epm1 = $e[$p-2] / $scale;
|
||||
$sk = $this->s[$k] / $scale;
|
||||
$ek = $e[$k] / $scale;
|
||||
$b = (($spm1 + $sp) * ($spm1 - $sp) + $epm1 * $epm1) / 2.0;
|
||||
$c = ($sp * $epm1) * ($sp * $epm1);
|
||||
$shift = 0.0;
|
||||
if (($b != 0.0) || ($c != 0.0)) {
|
||||
$shift = sqrt($b * $b + $c);
|
||||
if ($b < 0.0)
|
||||
$shift = -$shift;
|
||||
$shift = $c / ($b + $shift);
|
||||
}
|
||||
$f = ($sk + $sp) * ($sk - $sp) + $shift;
|
||||
$g = $sk * $ek;
|
||||
// Chase zeros.
|
||||
for ($j = $k; $j < $p-1; $j++) {
|
||||
$t = hypo($f,$g);
|
||||
$cs = $f/$t;
|
||||
$sn = $g/$t;
|
||||
if ($j != $k)
|
||||
$e[$j-1] = $t;
|
||||
$f = $cs * $this->s[$j] + $sn * $e[$j];
|
||||
$e[$j] = $cs * $e[$j] - $sn * $this->s[$j];
|
||||
$g = $sn * $this->s[$j+1];
|
||||
$this->s[$j+1] = $cs * $this->s[$j+1];
|
||||
if ($wantv) {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$j+1];
|
||||
$this->V[$i][$j+1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$j+1];
|
||||
$this->V[$i][$j] = $t;
|
||||
}
|
||||
}
|
||||
$t = hypo($f,$g);
|
||||
$cs = $f/$t;
|
||||
$sn = $g/$t;
|
||||
$this->s[$j] = $t;
|
||||
$f = $cs * $e[$j] + $sn * $this->s[$j+1];
|
||||
$this->s[$j+1] = -$sn * $e[$j] + $cs * $this->s[$j+1];
|
||||
$g = $sn * $e[$j+1];
|
||||
$e[$j+1] = $cs * $e[$j+1];
|
||||
if ($wantu && ($j < $this->m - 1)) {
|
||||
for ($i = 0; $i < $this->m; $i++) {
|
||||
$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$j+1];
|
||||
$this->U[$i][$j+1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$j+1];
|
||||
$this->U[$i][$j] = $t;
|
||||
}
|
||||
}
|
||||
}
|
||||
$e[$p-2] = $f;
|
||||
$iter = $iter + 1;
|
||||
break;
|
||||
// Convergence.
|
||||
case 4:
|
||||
// Make the singular values positive.
|
||||
if ($this->s[$k] <= 0.0) {
|
||||
$this->s[$k] = ($this->s[$k] < 0.0 ? -$this->s[$k] : 0.0);
|
||||
if ($wantv) {
|
||||
for ($i = 0; $i <= $pp; $i++)
|
||||
$this->V[$i][$k] = -$this->V[$i][$k];
|
||||
}
|
||||
}
|
||||
// Order the singular values.
|
||||
while ($k < $pp) {
|
||||
if ($this->s[$k] >= $this->s[$k+1])
|
||||
break;
|
||||
$t = $this->s[$k];
|
||||
$this->s[$k] = $this->s[$k+1];
|
||||
$this->s[$k+1] = $t;
|
||||
if ($wantv AND ($k < $this->n - 1)) {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
$t = $this->V[$i][$k+1];
|
||||
$this->V[$i][$k+1] = $this->V[$i][$k];
|
||||
$this->V[$i][$k] = $t;
|
||||
}
|
||||
}
|
||||
if ($wantu AND ($k < $this->m-1)) {
|
||||
for ($i = 0; $i < $this->m; $i++) {
|
||||
$t = $this->U[$i][$k+1];
|
||||
$this->U[$i][$k+1] = $this->U[$i][$k];
|
||||
$this->U[$i][$k] = $t;
|
||||
}
|
||||
}
|
||||
$k++;
|
||||
}
|
||||
$iter = 0;
|
||||
$p--;
|
||||
break;
|
||||
} // end switch
|
||||
} // end while
|
||||
|
||||
/*
|
||||
echo "<p>Output A</p>";
|
||||
$A = new Matrix($A);
|
||||
$A->toHTML();
|
||||
|
||||
echo "<p>Matrix U</p>";
|
||||
echo "<pre>";
|
||||
print_r($this->U);
|
||||
echo "</pre>";
|
||||
|
||||
echo "<p>Matrix V</p>";
|
||||
echo "<pre>";
|
||||
print_r($this->V);
|
||||
echo "</pre>";
|
||||
|
||||
echo "<p>Vector S</p>";
|
||||
echo "<pre>";
|
||||
print_r($this->s);
|
||||
echo "</pre>";
|
||||
exit;
|
||||
*/
|
||||
|
||||
} // end constructor
|
||||
|
||||
/**
|
||||
* Return the left singular vectors
|
||||
* @access public
|
||||
* @return U
|
||||
*/
|
||||
function getU() {
|
||||
return new Matrix($this->U, $this->m, min($this->m + 1, $this->n));
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the right singular vectors
|
||||
* @access public
|
||||
* @return V
|
||||
*/
|
||||
function getV() {
|
||||
return new Matrix($this->V);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the one-dimensional array of singular values
|
||||
* @access public
|
||||
* @return diagonal of S.
|
||||
*/
|
||||
function getSingularValues() {
|
||||
return $this->s;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the diagonal matrix of singular values
|
||||
* @access public
|
||||
* @return S
|
||||
*/
|
||||
function getS() {
|
||||
for ($i = 0; $i < $this->n; $i++) {
|
||||
for ($j = 0; $j < $this->n; $j++)
|
||||
$S[$i][$j] = 0.0;
|
||||
$S[$i][$i] = $this->s[$i];
|
||||
}
|
||||
return new Matrix($S);
|
||||
}
|
||||
|
||||
/**
|
||||
* Two norm
|
||||
* @access public
|
||||
* @return max(S)
|
||||
*/
|
||||
function norm2() {
|
||||
return $this->s[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Two norm condition number
|
||||
* @access public
|
||||
* @return max(S)/min(S)
|
||||
*/
|
||||
function cond() {
|
||||
return $this->s[0] / $this->s[min($this->m, $this->n) - 1];
|
||||
}
|
||||
|
||||
/**
|
||||
* Effective numerical matrix rank
|
||||
* @access public
|
||||
* @return Number of nonnegligible singular values.
|
||||
*/
|
||||
function rank() {
|
||||
$eps = pow(2.0, -52.0);
|
||||
$tol = max($this->m, $this->n) * $this->s[0] * $eps;
|
||||
$r = 0;
|
||||
for ($i = 0; $i < count($this->s); $i++) {
|
||||
if ($this->s[$i] > $tol)
|
||||
$r++;
|
||||
}
|
||||
return $r;
|
||||
}
|
||||
}
|
||||
6
include/PHPExcel/PHPExcel/Shared/JAMA/docs/docs.php
Executable file
6
include/PHPExcel/PHPExcel/Shared/JAMA/docs/docs.php
Executable file
@@ -0,0 +1,6 @@
|
||||
<?php
|
||||
require_once "includes/header.php";
|
||||
require_once "includes/navbar.php";
|
||||
require_once "sections/Home.php";
|
||||
require_once "includes/footer.php";
|
||||
?>
|
||||
65
include/PHPExcel/PHPExcel/Shared/JAMA/docs/download.php
Executable file
65
include/PHPExcel/PHPExcel/Shared/JAMA/docs/download.php
Executable file
@@ -0,0 +1,65 @@
|
||||
<?php
|
||||
/**
|
||||
* Script to create REGRESS package for download
|
||||
*
|
||||
* @author Mike Bommarito
|
||||
* @author Paul Meagher
|
||||
* @version 0.3
|
||||
* @modified Apr 2, 2006
|
||||
*
|
||||
* Note: Script requires the PEAR Archive_Tar package be installed:
|
||||
*
|
||||
* @see http://pear.php.net/package/Archive_Tar
|
||||
*/
|
||||
|
||||
// name and directory of package
|
||||
$pkgName = "JAMA";
|
||||
|
||||
// root of PHP/Math build directory
|
||||
$buildDir = substr(dirname(__FILE__), 0, -5 - strlen($pkgName));
|
||||
|
||||
// switch to PHP/Math build directory
|
||||
chdir($buildDir);
|
||||
|
||||
$tarName = "$pkgName.tar.gz";
|
||||
|
||||
$tarPath = $buildDir.$pkgName."/downloads/".$tarName;
|
||||
|
||||
if($_GET['op'] == "download") {
|
||||
|
||||
require_once('Archive/Tar.php');
|
||||
|
||||
$tar = new Archive_Tar($tarPath);
|
||||
|
||||
// create $pkgName archive under $pkgName folder
|
||||
$files = glob("$pkgName/*.php");
|
||||
$files = array_merge($files, glob("$pkgName/*.TXT"));
|
||||
$files = array_merge($files, glob("$pkgName/docs/*.php"));
|
||||
$files = array_merge($files, glob("$pkgName/docs/includes/*.php"));
|
||||
$files = array_merge($files, glob("$pkgName/examples/*.php"));
|
||||
$files = array_merge($files, glob("$pkgName/tests/*.php"));
|
||||
$files = array_merge($files, glob("$pkgName/utils/*.php"));
|
||||
|
||||
$tar->create($files);
|
||||
|
||||
// create the download url
|
||||
$webDir = substr($_SERVER['PHP_SELF'], 0, -18);
|
||||
$urlPath = "http://".$_SERVER['HTTP_HOST'].$webDir."/downloads";
|
||||
|
||||
// redirect to download url
|
||||
header("Location: $urlPath/$tarName");
|
||||
|
||||
}
|
||||
|
||||
include_once "includes/header.php";
|
||||
include_once "includes/navbar.php";
|
||||
?>
|
||||
<p>
|
||||
Download current version:
|
||||
</p>
|
||||
<ul>
|
||||
<li><a href='<?php echo $_SERVER['PHP_SELF']."?op=download"; ?>'><?php echo $tarName ?></a></li>
|
||||
</ul>
|
||||
<?php
|
||||
include_once "includes/footer.php";
|
||||
?>
|
||||
166
include/PHPExcel/PHPExcel/Shared/JAMA/docs/example.php
Executable file
166
include/PHPExcel/PHPExcel/Shared/JAMA/docs/example.php
Executable file
@@ -0,0 +1,166 @@
|
||||
<?php
|
||||
include_once "includes/header.php";
|
||||
include_once "includes/navbar.php";
|
||||
?>
|
||||
<h2>Magic Square Example</h2>
|
||||
<p>
|
||||
The Jama distribution comes with a magic square example that is used to
|
||||
test and benchmark the LU, QR, SVD and symmetric Eig decompositions.
|
||||
The example outputs a multi-column table with these column headings:
|
||||
</p>
|
||||
|
||||
<table border='1' cellpadding='5' cellspacing='0' align='center'>
|
||||
<tr>
|
||||
<td><b>n</b></td>
|
||||
<td>Order of magic square.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>trace</b></td>
|
||||
<td>Diagonal sum, should be the magic sum, (n^3 + n)/2.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>max_eig</b></td>
|
||||
<td>Maximum eigenvalue of (A + A')/2, should equal trace.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>rank</b></td>
|
||||
<td>Linear algebraic rank, should equal n if n is odd, be less than n if n is even.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>cond</b></td>
|
||||
<td>L_2 condition number, ratio of singular values.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>lu_res</b></td>
|
||||
<td>test of LU factorization, norm1(L*U-A(p,:))/(n*eps).</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><b>qr_res</b></td>
|
||||
<td>test of QR factorization, norm1(Q*R-A)/(n*eps).</td>
|
||||
</tr>
|
||||
</table>
|
||||
<p>
|
||||
Running the Java-based version of the matix square example produces these results:
|
||||
</p>
|
||||
|
||||
<table border='1' align='center'>
|
||||
<tr>
|
||||
<th> n </th>
|
||||
<th> trace </th>
|
||||
<th> max_eig </th>
|
||||
<th> rank </th>
|
||||
<th> cond </th>
|
||||
<th> lu_res </th>
|
||||
<th> qr_res </th>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>3</td><td>15</td><td>15.000</td><td>3</td><td>4.330</td><td>0.000</td><td>11.333</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>4</td><td>34</td><td>34.000</td><td>3</td><td> Inf</td><td>0.000</td><td>13.500</td>
|
||||
<tr>
|
||||
<td>5</td><td>65</td><td>65.000</td><td>5</td><td>5.462</td><td>0.000</td><td>14.400</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>6</td><td>111</td><td>111.000</td><td>5</td><td> Inf</td><td>5.333</td><td>16.000</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>7</td><td>175</td><td>175.000</td><td>7</td><td>7.111</td><td>2.286</td><td>37.714</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>8</td><td>260</td><td>260.000</td><td>3</td><td> Inf</td><td>0.000</td><td>59.000</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>9</td><td>369</td><td>369.000</td><td>9</td><td>9.102</td><td>7.111</td><td>53.333</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>10</td><td>505</td><td>505.000</td><td>7</td><td> Inf</td><td>3.200</td><td>159.200</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>11</td><td>671</td><td>671.000</td><td>11</td><td>11.102</td><td>2.909</td><td>215.273</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>12</td><td>870</td><td>870.000</td><td>3</td><td> Inf</td><td>0.000</td><td>185.333</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>13</td><td>1105</td><td>1105.000</td><td>13</td><td>13.060</td><td>4.923</td><td>313.846</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>14</td><td>1379</td><td>1379.000</td><td>9</td><td> Inf</td><td>4.571</td><td>540.571</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>15</td><td>1695</td><td>1695.000</td><td>15</td><td>15.062</td><td>4.267</td><td>242.133</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>16</td><td>2056</td><td>2056.000</td><td>3</td><td> Inf</td><td>0.000</td><td>488.500</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>17</td><td>2465</td><td>2465.000</td><td>17</td><td>17.042</td><td>7.529</td><td>267.294</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>18</td><td>2925</td><td>2925.000</td><td>11</td><td> Inf</td><td>7.111</td><td>520.889</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>19</td><td>3439</td><td>3439.000</td><td>19</td><td>19.048</td><td>16.842</td><td>387.368</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>20</td><td>4010</td><td>4010.000</td><td>3</td><td> Inf</td><td>14.400</td><td>584.800</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>21</td><td>4641</td><td>4641.000</td><td>21</td><td>21.035</td><td>6.095</td><td>1158.095</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>22</td><td>5335</td><td>5335.000</td><td>13</td><td> Inf</td><td>6.545</td><td>1132.364</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>23</td><td>6095</td><td>6095.000</td><td>23</td><td>23.037</td><td>11.130</td><td>1268.870</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>24</td><td>6924</td><td>6924.000</td><td>3</td><td> Inf</td><td>10.667</td><td>827.500</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>25</td><td>7825</td><td>7825.000</td><td>25</td><td>25.029</td><td>35.840</td><td>1190.400</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>26</td><td>8801</td><td>8801.000</td><td>15</td><td> Inf</td><td>4.923</td><td>1859.077</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>27</td><td>9855</td><td>9855.000</td><td>27</td><td>27.032</td><td>37.926</td><td>1365.333</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>28</td><td>10990</td><td>10990.000</td><td>3</td><td> Inf</td><td>34.286</td><td>1365.714</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>29</td><td>12209</td><td>12209.000</td><td>29</td><td>29.025</td><td>30.897</td><td>1647.448</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>30</td><td>13515</td><td>13515.000</td><td>17</td><td> Inf</td><td>8.533</td><td>2571.733</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>31</td><td>14911</td><td>14911.000</td><td>31</td><td>31.027</td><td>33.032</td><td>1426.581</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td>32</td><td>16400</td><td>16400.000</td><td>3</td><td> Inf</td><td>0.000</td><td>1600.125</td>
|
||||
</tr>
|
||||
</table>
|
||||
<center>Elapsed Time = 0.710 seconds</center>
|
||||
|
||||
<p>
|
||||
The magic square example does not fare well when <a href='../examples/MagicSquareExample.php'>run as a PHP script</a>. For a 32x32 matrix array
|
||||
it takes around a second to complete just the last row of computations in the above table.
|
||||
Hopefully this result will spur PHP developers to find optimizations and better attuned algorithms
|
||||
to speed things up. Matrix algebra is a great testing ground for ideas about time and memory
|
||||
performance optimation. Keep in perspective that PHP JAMA scripts are still plenty fast for use as
|
||||
a tool for learning about matrix algebra and quickly extending your knowledge with new scripts
|
||||
to apply knowledge.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
To learn more about the subject of magic squares you can visit the <a href='http://mathforum.org/alejandre/magic.square.html'>Drexel Math Forum on Magic Squares</a>.
|
||||
You can also learn more by carefully examining the <code>MagicSquareExample.php</code> source code below.
|
||||
</p>
|
||||
|
||||
<?php
|
||||
highlight_file("../examples/MagicSquareExample.php");
|
||||
include_once "includes/footer.php";
|
||||
?>
|
||||
14
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/credits.php
Executable file
14
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/credits.php
Executable file
@@ -0,0 +1,14 @@
|
||||
<div id="credits">
|
||||
<p>
|
||||
Brought to you by:
|
||||
</p>
|
||||
<ul>
|
||||
<li><a href="http://math.nist.gov/">National Institute of Standards and Technology</a></h2></li>
|
||||
<li><a href="http://math.nist.gov/">MathWorks</a></li>
|
||||
<li><a href="http://math.nist.gov/javanumerics/jama/">JAMA : A Java Matrix Package</a></h2></li>
|
||||
<li>Paul Meagher</li>
|
||||
<li>Michael Bommarito</li>
|
||||
<li>Lukasz Karapuda</li>
|
||||
<li>Bartek Matosiuk</li>
|
||||
</ul>
|
||||
</div>
|
||||
2
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/footer.php
Executable file
2
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/footer.php
Executable file
@@ -0,0 +1,2 @@
|
||||
</body>
|
||||
</html>
|
||||
11
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/header.php
Executable file
11
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/header.php
Executable file
@@ -0,0 +1,11 @@
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
||||
<head>
|
||||
<title>JAMA v1.0.1</title>
|
||||
<meta name="description" content="JAMA v1.0.1 - Port of the proposed standard Java Matrix Library to PHP" />
|
||||
<meta name="robots" content="index, follow" />
|
||||
<meta name="keywords" content="php, matrix, matrix library, cholesky decomposition, eigenvalue decomposition, eigenvector, lu decomposition, qr decomposition, singular value decomposition" />
|
||||
<link rel="stylesheet" type="text/css" href="style.css" />
|
||||
</head>
|
||||
<body>
|
||||
5
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/navbar.php
Executable file
5
include/PHPExcel/PHPExcel/Shared/JAMA/docs/includes/navbar.php
Executable file
@@ -0,0 +1,5 @@
|
||||
<center>
|
||||
<hr />
|
||||
[ <a href="index.php">index.php</a> ] [ <a href="docs.php">docs.php</a> ] [ <a href="package.php">package.php</a> ] [ <a href="test.php">test.php</a> ] [ <a href="example.php">example.php</a> ] [ <a href="download.php">download.php</a></h2> ]
|
||||
<hr />
|
||||
</center>
|
||||
30
include/PHPExcel/PHPExcel/Shared/JAMA/docs/index.php
Executable file
30
include/PHPExcel/PHPExcel/Shared/JAMA/docs/index.php
Executable file
@@ -0,0 +1,30 @@
|
||||
<?php
|
||||
include_once "includes/header.php";
|
||||
include_once "includes/navbar.php";
|
||||
?>
|
||||
|
||||
<p>
|
||||
JAMA is a proposed standard matrix class for Java. The JAMA introduction
|
||||
describes "JAMA : A Java Matrix Package" in this way:
|
||||
</p>
|
||||
|
||||
<blockquote>
|
||||
JAMA is a basic linear algebra package for Java. It provides user-level classes for
|
||||
constructing and manipulating real, dense matrices. It is meant to provide sufficient
|
||||
functionality for routine problems, packaged in a way that is natural and understandable
|
||||
to non-experts. It is intended to serve as the standard matrix class for Java, and
|
||||
will be proposed as such to the Java Grande Forum and then to Sun. A straightforward
|
||||
public-domain reference implementation has been developed by the MathWorks and NIST as
|
||||
a strawman for such a class. We are releasing this version in order to obtain public
|
||||
comment. There is no guarantee that future versions of JAMA will be compatible with this one.
|
||||
</blockquote>
|
||||
|
||||
<p>
|
||||
The development team below has successfully ported the JAMA API to PHP. You can explore
|
||||
this site to learn more about this project and it's current development status.
|
||||
</p>
|
||||
|
||||
<?php
|
||||
include_once "includes/credits.php";
|
||||
include_once "includes/footer.php";
|
||||
?>
|
||||
37
include/PHPExcel/PHPExcel/Shared/JAMA/docs/package.php
Executable file
37
include/PHPExcel/PHPExcel/Shared/JAMA/docs/package.php
Executable file
@@ -0,0 +1,37 @@
|
||||
<?php
|
||||
include_once "includes/header.php";
|
||||
include_once "includes/navbar.php";
|
||||
?>
|
||||
<p>
|
||||
Source Listing:
|
||||
</p>
|
||||
<ul>
|
||||
<?php
|
||||
chdir("../");
|
||||
$files = glob("*.php");
|
||||
$files = array_merge($files, glob("util/*.php"));
|
||||
foreach ($files as $fileName) {
|
||||
?>
|
||||
<li><a href="package.php?view=<?php echo sha1($fileName);?>"><?php echo $fileName;?></a> - <?php echo date ("F d Y - g:i a", filemtime($fileName));?></li>
|
||||
<?php
|
||||
}
|
||||
?>
|
||||
</ul>
|
||||
<?php
|
||||
if( isset($_REQUEST['view']) ) {
|
||||
$hash = $_REQUEST['view'];
|
||||
$n = array_search($hash, array_map(sha1, $files));
|
||||
$fileName = $files[$n];
|
||||
?>
|
||||
<hr />
|
||||
Viewing: <?php echo $fileName;?>
|
||||
<hr />
|
||||
<?php
|
||||
highlight_file($fileName);
|
||||
?>
|
||||
<hr />
|
||||
<?php
|
||||
}
|
||||
include_once "includes/footer.php";
|
||||
?>
|
||||
|
||||
28
include/PHPExcel/PHPExcel/Shared/JAMA/docs/test.php
Executable file
28
include/PHPExcel/PHPExcel/Shared/JAMA/docs/test.php
Executable file
@@ -0,0 +1,28 @@
|
||||
<?php
|
||||
include_once "includes/header.php";
|
||||
include_once "includes/navbar.php";
|
||||
?>
|
||||
<p>
|
||||
The first script your should run when you install Jama is the TestMatrix.php script.
|
||||
</p>
|
||||
<p>
|
||||
This will run the unit tests for methods in the <code>Matrix.php</code> class. Because
|
||||
the Matrix.php class can be used to invoke all the decomposition methods the <code>TestMatrix.php</code>
|
||||
script is a test suite for the whole Jama package.
|
||||
</p>
|
||||
<p>
|
||||
The original <code>TestMatrix.java</code> code uses try/catch error handling. We will
|
||||
eventually create a build of JAMA that will take advantage of PHP5's new try/catch error
|
||||
handling capabilities. This will improve our ability to replicate all the unit tests that
|
||||
appeared in the original (except for some print methods that may not be worth porting).
|
||||
</p>
|
||||
<p>
|
||||
You can <a href='../test/TestMatrix.php'>run the TestMatrix.php script</a> to see what
|
||||
unit tests are currently implemented. The source of the <code>TestMatrix.php</code> script
|
||||
is provided below. It is worth studying carefully for an example of how to do matrix algebra
|
||||
programming with Jama.
|
||||
</p>
|
||||
<?php
|
||||
highlight_file("../test/TestMatrix.php");
|
||||
include_once "includes/footer.php";
|
||||
?>
|
||||
120
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LMQuadTest.php
Executable file
120
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LMQuadTest.php
Executable file
@@ -0,0 +1,120 @@
|
||||
<?php
|
||||
/**
|
||||
* quadratic (p-o)'S'S(p-o)
|
||||
* solve for o, S
|
||||
* S is a single scale factor
|
||||
*/
|
||||
class LMQuadTest {
|
||||
|
||||
/**
|
||||
* @param array[] $x
|
||||
* @param array[] $a
|
||||
*/
|
||||
function val($x, $a) {
|
||||
|
||||
if (count($a) != 3) die ("Wrong number of elements in array a");
|
||||
if (count($x) != 2) die ("Wrong number of elements in array x");
|
||||
|
||||
$ox = $a[0];
|
||||
$oy = $a[1];
|
||||
$s = $a[2];
|
||||
|
||||
$sdx = $s*($x[0] - $ox);
|
||||
$sdy = $s*($x[1] - $oy);
|
||||
|
||||
return $sdx*$sdx + $sdy*$sdy;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* z = (p-o)'S'S(p-o)
|
||||
* dz/dp = 2S'S(p-o)
|
||||
*
|
||||
* z = (s*(px-ox))^2 + (s*(py-oy))^2
|
||||
* dz/dox = -2(s*(px-ox))*s
|
||||
* dz/ds = 2*s*[(px-ox)^2 + (py-oy)^2]
|
||||
*
|
||||
* z = (s*dx)^2 + (s*dy)^2
|
||||
* dz/ds = 2(s*dx)*dx + 2(s*dy)*dy
|
||||
*
|
||||
* @param array[] $x
|
||||
* @param array[] $a
|
||||
* @param int $a_k
|
||||
* @param array[] $a
|
||||
*/
|
||||
function grad(double[] x, double[] a, int a_k) {
|
||||
|
||||
if (count($a) != 3) die ("Wrong number of elements in array a");
|
||||
if (count($x) != 2) die ("Wrong number of elements in array x");
|
||||
if ($a_k < 3) die ("a_k=".$a_k;);
|
||||
|
||||
$ox = $a[0];
|
||||
$oy = $a[1];
|
||||
$s = $a[2];
|
||||
|
||||
$dx = ($x[0] - $ox);
|
||||
$dy = ($x[1] - $oy);
|
||||
|
||||
if ($a_k == 0)
|
||||
return -2.*$s*$s*$dx;
|
||||
elseif ($a_k == 1)
|
||||
return -2.*$s*$s*$dy;
|
||||
else
|
||||
return 2.*$s*($dx*$dx + $dy*$dy);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @return array[] $a
|
||||
*/
|
||||
function initial() {
|
||||
$a[0] = 0.05;
|
||||
$a[1] = 0.1;
|
||||
$a[2] = 1.0;
|
||||
return $a;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @return Object[] $a
|
||||
*/
|
||||
function testdata() {
|
||||
|
||||
$npts = 25;
|
||||
|
||||
$a[0] = 0.;
|
||||
$a[1] = 0.;
|
||||
$a[2] = 0.9;
|
||||
|
||||
$i = 0;
|
||||
|
||||
for($r = -2; $r <= 2; $r++ ) {
|
||||
for($c = -2; $c <= 2; $c++ ) {
|
||||
$x[$i][0] = $c;
|
||||
$x[$i][1] = $r;
|
||||
$y[$i] = $this->val($x[$i], $a);
|
||||
print("Quad ".$c.",".$r." -> ".$y[$i]."<br />");
|
||||
$s[$i] = 1.;
|
||||
$i++;
|
||||
}
|
||||
}
|
||||
print("quad x= ");
|
||||
|
||||
$qx = new Matrix($x);
|
||||
$qx->print(10, 2);
|
||||
|
||||
print("quad y= ");
|
||||
$qy = new Matrix($y, $npts);
|
||||
$qy->print(10, 2);
|
||||
|
||||
$o[0] = $x;
|
||||
$o[1] = $a;
|
||||
$o[2] = $y;
|
||||
$o[3] = $s;
|
||||
|
||||
return $o;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
62
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LagrangeInterpolation.php
Executable file
62
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LagrangeInterpolation.php
Executable file
@@ -0,0 +1,62 @@
|
||||
<?php
|
||||
|
||||
require_once "../Matrix.php";
|
||||
|
||||
/**
|
||||
* Given n points (x0,y0)...(xn-1,yn-1), the following methid computes
|
||||
* the polynomial factors of the n-1't degree polynomial passing through
|
||||
* the n points.
|
||||
*
|
||||
* Example: Passing in three points (2,3) (1,4) and (3,7) will produce
|
||||
* the results [2.5, -8.5, 10] which means that the points are on the
|
||||
* curve y = 2.5x<EFBFBD> - 8.5x + 10.
|
||||
*
|
||||
* @see http://geosoft.no/software/lagrange/LagrangeInterpolation.java.html
|
||||
* @author Jacob Dreyer
|
||||
* @author Paul Meagher (port to PHP and minor changes)
|
||||
*
|
||||
* @param x[] float
|
||||
* @param y[] float
|
||||
*/
|
||||
class LagrangeInterpolation {
|
||||
|
||||
public function findPolynomialFactors($x, $y) {
|
||||
|
||||
$n = count($x);
|
||||
|
||||
$data = array(); // double[n][n];
|
||||
$rhs = array(); // double[n];
|
||||
|
||||
for ($i = 0; $i < $n; $i++) {
|
||||
$v = 1;
|
||||
for ($j = 0; $j < $n; $j++) {
|
||||
$data[$i][$n-$j-1] = $v;
|
||||
$v *= $x[$i];
|
||||
}
|
||||
|
||||
$rhs[$i] = $y[$i];
|
||||
}
|
||||
|
||||
// Solve m * s = b
|
||||
|
||||
$m = new Matrix($data);
|
||||
$b = new Matrix($rhs, $n);
|
||||
|
||||
$s = $m->solve($b);
|
||||
|
||||
return $s->getRowPackedCopy();
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
$x = array(2.0, 1.0, 3.0);
|
||||
$y = array(3.0, 4.0, 7.0);
|
||||
|
||||
$li = new LagrangeInterpolation;
|
||||
$f = $li->findPolynomialFactors($x, $y);
|
||||
|
||||
for ($i = 0; $i < 3; $i++)
|
||||
echo $f[$i]."<br />";
|
||||
|
||||
?>
|
||||
63
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LagrangeInterpolation2.php
Executable file
63
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LagrangeInterpolation2.php
Executable file
@@ -0,0 +1,63 @@
|
||||
<?php
|
||||
|
||||
require_once "../Matrix.php";
|
||||
|
||||
/**
|
||||
* Given n points (x0,y0)...(xn-1,yn-1), the following method computes
|
||||
* the polynomial factors of the n-1't degree polynomial passing through
|
||||
* the n points.
|
||||
*
|
||||
* Example: Passing in three points (2,3) (1,4) and (3,7) will produce
|
||||
* the results [2.5, -8.5, 10] which means that the points are on the
|
||||
* curve y = 2.5x<EFBFBD> - 8.5x + 10.
|
||||
*
|
||||
* @see http://geosoft.no/software/lagrange/LagrangeInterpolation.java.html
|
||||
* @see http://source.freehep.org/jcvsweb/ilc/LCSIM/wdview/lcsim/src/org/lcsim/fit/polynomial/PolynomialFitter.java
|
||||
* @author Jacob Dreyer
|
||||
* @author Paul Meagher (port to PHP and minor changes)
|
||||
*
|
||||
* @param x[] float
|
||||
* @param y[] float
|
||||
*/
|
||||
class LagrangeInterpolation {
|
||||
|
||||
public function findPolynomialFactors($x, $y) {
|
||||
|
||||
$n = count($x);
|
||||
|
||||
$data = array(); // double[n][n];
|
||||
$rhs = array(); // double[n];
|
||||
|
||||
for ($i = 0; $i < $n; $i++) {
|
||||
$v = 1;
|
||||
for ($j = 0; $j < $n; $j++) {
|
||||
$data[$i][$n-$j-1] = $v;
|
||||
$v *= $x[$i];
|
||||
}
|
||||
|
||||
$rhs[$i] = $y[$i];
|
||||
}
|
||||
|
||||
// Solve m * s = b
|
||||
|
||||
$m = new Matrix($data);
|
||||
$b = new Matrix($rhs, $n);
|
||||
|
||||
$s = $m->solve($b);
|
||||
|
||||
return $s->getRowPackedCopy();
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
$x = array(2.0, 1.0, 3.0);
|
||||
$y = array(3.0, 4.0, 7.0);
|
||||
|
||||
$li = new LagrangeInterpolation;
|
||||
$f = $li->findPolynomialFactors($x, $y);
|
||||
|
||||
for ($i = 0; $i < 3; $i++)
|
||||
echo $f[$i]."<br />";
|
||||
|
||||
?>
|
||||
191
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LevenbergMarquardt.php
Executable file
191
include/PHPExcel/PHPExcel/Shared/JAMA/examples/LevenbergMarquardt.php
Executable file
@@ -0,0 +1,191 @@
|
||||
<?php
|
||||
|
||||
// Levenberg-Marquardt in PHP
|
||||
|
||||
// http://www.idiom.com/~zilla/Computer/Javanumeric/LM.java
|
||||
|
||||
class LevenbergMarquardt {
|
||||
|
||||
/**
|
||||
* Calculate the current sum-squared-error
|
||||
*
|
||||
* Chi-squared is the distribution of squared Gaussian errors,
|
||||
* thus the name.
|
||||
*
|
||||
* @param double[][] $x
|
||||
* @param double[] $a
|
||||
* @param double[] $y,
|
||||
* @param double[] $s,
|
||||
* @param object $f
|
||||
*/
|
||||
function chiSquared($x, $a, $y, $s, $f) {
|
||||
|
||||
$npts = count($y);
|
||||
|
||||
$sum = 0.0;
|
||||
|
||||
for($i = 0; $i < $npts; $i++ ) {
|
||||
$d = $y[$i] - $f->val($x[$i], $a);
|
||||
$d = $d / $s[$i];
|
||||
$sum = $sum + ($d*$d);
|
||||
}
|
||||
|
||||
return $sum;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Minimize E = sum {(y[k] - f(x[k],a)) / s[k]}^2
|
||||
* The individual errors are optionally scaled by s[k].
|
||||
* Note that LMfunc implements the value and gradient of f(x,a),
|
||||
* NOT the value and gradient of E with respect to a!
|
||||
*
|
||||
* @param x array of domain points, each may be multidimensional
|
||||
* @param y corresponding array of values
|
||||
* @param a the parameters/state of the model
|
||||
* @param vary false to indicate the corresponding a[k] is to be held fixed
|
||||
* @param s2 sigma^2 for point i
|
||||
* @param lambda blend between steepest descent (lambda high) and
|
||||
* jump to bottom of quadratic (lambda zero).
|
||||
* Start with 0.001.
|
||||
* @param termepsilon termination accuracy (0.01)
|
||||
* @param maxiter stop and return after this many iterations if not done
|
||||
* @param verbose set to zero (no prints), 1, 2
|
||||
*
|
||||
* @return the new lambda for future iterations.
|
||||
* Can use this and maxiter to interleave the LM descent with some other
|
||||
* task, setting maxiter to something small.
|
||||
*/
|
||||
function solve($x, $a, $y, $s, $vary, $f, $lambda, $termepsilon, $maxiter, $verbose) {
|
||||
|
||||
$npts = count($y);
|
||||
$nparm = count($a);
|
||||
|
||||
if ($verbose > 0) {
|
||||
print("solve x[".count($x)."][".count($x[0])."]");
|
||||
print(" a[".count($a)."]");
|
||||
println(" y[".count(length)."]");
|
||||
}
|
||||
|
||||
$e0 = $this->chiSquared($x, $a, $y, $s, $f);
|
||||
|
||||
//double lambda = 0.001;
|
||||
$done = false;
|
||||
|
||||
// g = gradient, H = hessian, d = step to minimum
|
||||
// H d = -g, solve for d
|
||||
$H = array();
|
||||
$g = array();
|
||||
|
||||
//double[] d = new double[nparm];
|
||||
|
||||
$oos2 = array();
|
||||
|
||||
for($i = 0; $i < $npts; $i++) $oos2[$i] = 1./($s[$i]*$s[$i]);
|
||||
|
||||
$iter = 0;
|
||||
$term = 0; // termination count test
|
||||
|
||||
do {
|
||||
++$iter;
|
||||
|
||||
// hessian approximation
|
||||
for( $r = 0; $r < $nparm; $r++ ) {
|
||||
for( $c = 0; $c < $nparm; $c++ ) {
|
||||
for( $i = 0; $i < $npts; $i++ ) {
|
||||
if ($i == 0) $H[$r][$c] = 0.;
|
||||
$xi = $x[$i];
|
||||
$H[$r][$c] += ($oos2[$i] * $f->grad($xi, $a, $r) * $f->grad($xi, $a, $c));
|
||||
} //npts
|
||||
} //c
|
||||
} //r
|
||||
|
||||
// boost diagonal towards gradient descent
|
||||
for( $r = 0; $r < $nparm; $r++ )
|
||||
$H[$r][$r] *= (1. + $lambda);
|
||||
|
||||
// gradient
|
||||
for( $r = 0; $r < $nparm; $r++ ) {
|
||||
for( $i = 0; $i < $npts; $i++ ) {
|
||||
if ($i == 0) $g[$r] = 0.;
|
||||
$xi = $x[$i];
|
||||
$g[$r] += ($oos2[$i] * ($y[$i]-$f->val($xi,$a)) * $f->grad($xi, $a, $r));
|
||||
}
|
||||
} //npts
|
||||
|
||||
// scale (for consistency with NR, not necessary)
|
||||
if ($false) {
|
||||
for( $r = 0; $r < $nparm; $r++ ) {
|
||||
$g[$r] = -0.5 * $g[$r];
|
||||
for( $c = 0; $c < $nparm; $c++ ) {
|
||||
$H[$r][$c] *= 0.5;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// solve H d = -g, evaluate error at new location
|
||||
//double[] d = DoubleMatrix.solve(H, g);
|
||||
double[] d = (new Matrix(H)).lu().solve(new Matrix(g, nparm)).getRowPackedCopy();
|
||||
//double[] na = DoubleVector.add(a, d);
|
||||
double[] na = (new Matrix(a, nparm)).plus(new Matrix(d, nparm)).getRowPackedCopy();
|
||||
double e1 = chiSquared(x, na, y, s, f);
|
||||
|
||||
if (verbose > 0) {
|
||||
System.out.println("\n\niteration "+iter+" lambda = "+lambda);
|
||||
System.out.print("a = ");
|
||||
(new Matrix(a, nparm)).print(10, 2);
|
||||
if (verbose > 1) {
|
||||
System.out.print("H = ");
|
||||
(new Matrix(H)).print(10, 2);
|
||||
System.out.print("g = ");
|
||||
(new Matrix(g, nparm)).print(10, 2);
|
||||
System.out.print("d = ");
|
||||
(new Matrix(d, nparm)).print(10, 2);
|
||||
}
|
||||
System.out.print("e0 = " + e0 + ": ");
|
||||
System.out.print("moved from ");
|
||||
(new Matrix(a, nparm)).print(10, 2);
|
||||
System.out.print("e1 = " + e1 + ": ");
|
||||
if (e1 < e0) {
|
||||
System.out.print("to ");
|
||||
(new Matrix(na, nparm)).print(10, 2);
|
||||
} else {
|
||||
System.out.println("move rejected");
|
||||
}
|
||||
}
|
||||
|
||||
// termination test (slightly different than NR)
|
||||
if (Math.abs(e1-e0) > termepsilon) {
|
||||
term = 0;
|
||||
} else {
|
||||
term++;
|
||||
if (term == 4) {
|
||||
System.out.println("terminating after " + iter + " iterations");
|
||||
done = true;
|
||||
}
|
||||
}
|
||||
if (iter >= maxiter) done = true;
|
||||
|
||||
// in the C++ version, found that changing this to e1 >= e0
|
||||
// was not a good idea. See comment there.
|
||||
//
|
||||
if (e1 > e0 || Double.isNaN(e1)) { // new location worse than before
|
||||
lambda *= 10.;
|
||||
} else { // new location better, accept new parameters
|
||||
lambda *= 0.1;
|
||||
e0 = e1;
|
||||
// simply assigning a = na will not get results copied back to caller
|
||||
for( int i = 0; i < nparm; i++ ) {
|
||||
if (vary[i]) a[i] = na[i];
|
||||
}
|
||||
}
|
||||
} while(!$done);
|
||||
|
||||
return $lambda;
|
||||
|
||||
} //solve
|
||||
|
||||
}
|
||||
|
||||
?>
|
||||
183
include/PHPExcel/PHPExcel/Shared/JAMA/examples/MagicSquareExample.php
Executable file
183
include/PHPExcel/PHPExcel/Shared/JAMA/examples/MagicSquareExample.php
Executable file
@@ -0,0 +1,183 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*/
|
||||
|
||||
require_once "../Matrix.php";
|
||||
|
||||
/**
|
||||
* Example of use of Matrix Class, featuring magic squares.
|
||||
*/
|
||||
class MagicSquareExample {
|
||||
|
||||
/**
|
||||
* Generate magic square test matrix.
|
||||
* @param int n dimension of matrix
|
||||
*/
|
||||
function magic($n) {
|
||||
|
||||
// Odd order
|
||||
|
||||
if (($n % 2) == 1) {
|
||||
$a = ($n+1)/2;
|
||||
$b = ($n+1);
|
||||
for ($j = 0; $j < $n; $j++)
|
||||
for ($i = 0; $i < $n; $i++)
|
||||
$M[$i][$j] = $n*(($i+$j+$a) % $n) + (($i+2*$j+$b) % $n) + 1;
|
||||
|
||||
// Doubly Even Order
|
||||
|
||||
} else if (($n % 4) == 0) {
|
||||
for ($j = 0; $j < $n; $j++) {
|
||||
for ($i = 0; $i < $n; $i++) {
|
||||
if ((($i+1)/2)%2 == (($j+1)/2)%2)
|
||||
$M[$i][$j] = $n*$n-$n*$i-$j;
|
||||
else
|
||||
$M[$i][$j] = $n*$i+$j+1;
|
||||
}
|
||||
}
|
||||
|
||||
// Singly Even Order
|
||||
|
||||
} else {
|
||||
|
||||
$p = $n/2;
|
||||
$k = ($n-2)/4;
|
||||
$A = $this->magic($p);
|
||||
$M = array();
|
||||
for ($j = 0; $j < $p; $j++) {
|
||||
for ($i = 0; $i < $p; $i++) {
|
||||
$aij = $A->get($i,$j);
|
||||
$M[$i][$j] = $aij;
|
||||
$M[$i][$j+$p] = $aij + 2*$p*$p;
|
||||
$M[$i+$p][$j] = $aij + 3*$p*$p;
|
||||
$M[$i+$p][$j+$p] = $aij + $p*$p;
|
||||
}
|
||||
}
|
||||
|
||||
for ($i = 0; $i < $p; $i++) {
|
||||
for ($j = 0; $j < $k; $j++) {
|
||||
$t = $M[$i][$j];
|
||||
$M[$i][$j] = $M[$i+$p][$j];
|
||||
$M[$i+$p][$j] = $t;
|
||||
}
|
||||
for ($j = $n-$k+1; $j < $n; $j++) {
|
||||
$t = $M[$i][$j];
|
||||
$M[$i][$j] = $M[$i+$p][$j];
|
||||
$M[$i+$p][$j] = $t;
|
||||
}
|
||||
}
|
||||
|
||||
$t = $M[$k][0]; $M[$k][0] = $M[$k+$p][0]; $M[$k+$p][0] = $t;
|
||||
$t = $M[$k][$k]; $M[$k][$k] = $M[$k+$p][$k]; $M[$k+$p][$k] = $t;
|
||||
|
||||
}
|
||||
|
||||
return new Matrix($M);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple function to replicate PHP 5 behaviour
|
||||
*/
|
||||
function microtime_float() {
|
||||
list($usec, $sec) = explode(" ", microtime());
|
||||
return ((float)$usec + (float)$sec);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests LU, QR, SVD and symmetric Eig decompositions.
|
||||
*
|
||||
* n = order of magic square.
|
||||
* trace = diagonal sum, should be the magic sum, (n^3 + n)/2.
|
||||
* max_eig = maximum eigenvalue of (A + A')/2, should equal trace.
|
||||
* rank = linear algebraic rank, should equal n if n is odd,
|
||||
* be less than n if n is even.
|
||||
* cond = L_2 condition number, ratio of singular values.
|
||||
* lu_res = test of LU factorization, norm1(L*U-A(p,:))/(n*eps).
|
||||
* qr_res = test of QR factorization, norm1(Q*R-A)/(n*eps).
|
||||
*/
|
||||
function main() {
|
||||
?>
|
||||
<p>Test of Matrix Class, using magic squares.</p>
|
||||
<p>See MagicSquareExample.main() for an explanation.</p>
|
||||
<table border='1' cellspacing='0' cellpadding='4'>
|
||||
<tr>
|
||||
<th>n</th>
|
||||
<th>trace</th>
|
||||
<th>max_eig</th>
|
||||
<th>rank</th>
|
||||
<th>cond</th>
|
||||
<th>lu_res</th>
|
||||
<th>qr_res</th>
|
||||
</tr>
|
||||
<?php
|
||||
$start_time = $this->microtime_float();
|
||||
$eps = pow(2.0,-52.0);
|
||||
for ($n = 3; $n <= 6; $n++) {
|
||||
|
||||
echo "<tr>";
|
||||
|
||||
echo "<td align='right'>$n</td>";
|
||||
|
||||
$M = $this->magic($n);
|
||||
$t = (int) $M->trace();
|
||||
|
||||
echo "<td align='right'>$t</td>";
|
||||
|
||||
$O = $M->plus($M->transpose());
|
||||
$E = new EigenvalueDecomposition($O->times(0.5));
|
||||
$d = $E->getRealEigenvalues();
|
||||
|
||||
echo "<td align='right'>".$d[$n-1]."</td>";
|
||||
|
||||
$r = $M->rank();
|
||||
|
||||
echo "<td align='right'>".$r."</td>";
|
||||
|
||||
$c = $M->cond();
|
||||
|
||||
if ($c < 1/$eps)
|
||||
echo "<td align='right'>".sprintf("%.3f",$c)."</td>";
|
||||
else
|
||||
echo "<td align='right'>Inf</td>";
|
||||
|
||||
$LU = new LUDecomposition($M);
|
||||
$L = $LU->getL();
|
||||
$U = $LU->getU();
|
||||
$p = $LU->getPivot();
|
||||
// Java version: R = L.times(U).minus(M.getMatrix(p,0,n-1));
|
||||
$S = $L->times($U);
|
||||
$R = $S->minus($M->getMatrix($p,0,$n-1));
|
||||
$res = $R->norm1()/($n*$eps);
|
||||
|
||||
echo "<td align='right'>".sprintf("%.3f",$res)."</td>";
|
||||
|
||||
$QR = new QRDecomposition($M);
|
||||
$Q = $QR->getQ();
|
||||
$R = $QR->getR();
|
||||
$S = $Q->times($R);
|
||||
$R = $S->minus($M);
|
||||
$res = $R->norm1()/($n*$eps);
|
||||
|
||||
echo "<td align='right'>".sprintf("%.3f",$res)."</td>";
|
||||
|
||||
echo "</tr>";
|
||||
|
||||
}
|
||||
echo "<table>";
|
||||
echo "<br />";
|
||||
|
||||
$stop_time = $this->microtime_float();
|
||||
$etime = $stop_time - $start_time;
|
||||
|
||||
echo "<p>Elapsed time is ". sprintf("%.4f",$etime) ." seconds.</p>";
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
$magic = new MagicSquareExample();
|
||||
$magic->main();
|
||||
|
||||
?>
|
||||
1605
include/PHPExcel/PHPExcel/Shared/JAMA/examples/Stats.php
Executable file
1605
include/PHPExcel/PHPExcel/Shared/JAMA/examples/Stats.php
Executable file
File diff suppressed because it is too large
Load Diff
244
include/PHPExcel/PHPExcel/Shared/JAMA/examples/benchmark.php
Executable file
244
include/PHPExcel/PHPExcel/Shared/JAMA/examples/benchmark.php
Executable file
@@ -0,0 +1,244 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*/
|
||||
|
||||
require_once "../Matrix.php";
|
||||
require_once "Stats.php";
|
||||
|
||||
/**
|
||||
* Example of use of Matrix Class, featuring magic squares.
|
||||
*/
|
||||
class Benchmark {
|
||||
var $stat;
|
||||
|
||||
/**
|
||||
* Simple function to replicate PHP 5 behaviour
|
||||
*/
|
||||
function microtime_float() {
|
||||
list($usec, $sec) = explode(" ", microtime());
|
||||
return ((float)$usec + (float)$sec);
|
||||
}
|
||||
|
||||
function Benchmark() {
|
||||
$this->stat = new Base();
|
||||
}
|
||||
|
||||
function displayStats( $times = null ) {
|
||||
$this->stat->setData($times);
|
||||
$stats = $this->stat->calcFull();
|
||||
echo '<table style="margin-left:32px;">';
|
||||
echo '<tr><td style="text-align:right;"><b>n:</b><td style="text-align:right;">' . $stats['count'] . ' </td></tr>';
|
||||
echo '<tr><td style="text-align:right;"><b>Mean:</b><td style="text-align:right;">' . $stats['mean'] . ' </td></tr>';
|
||||
echo '<tr><td style="text-align:right;"><b>Min.:</b><td style="text-align:right;">' . $stats['min'] . ' </td></tr>';
|
||||
echo '<tr><td style="text-align:right;"><b>Max.:</b><td style="text-align:right;">' . $stats['max'] . ' </td></tr>';
|
||||
echo '<tr><td style="text-align:right;"><b>σ:</b><td style="text-align:right;">' . $stats['stdev'] . ' </td></tr>';
|
||||
echo '<tr><td style="text-align:right;"><b>Variance:</b><td style="text-align:right;">' . $stats['variance'] . ' </td></tr>';
|
||||
echo '<tr><td style="text-align:right;"><b>Range:</b><td style="text-align:right;">' . $stats['range'] . ' </td></tr>';
|
||||
echo '</table>';
|
||||
return $stats;
|
||||
}
|
||||
|
||||
|
||||
function runEig($n = 4, $t = 100) {
|
||||
$times = array();
|
||||
|
||||
for( $i = 0; $i < $t; $i++ ) {
|
||||
$M = Matrix::random($n, $n);
|
||||
$start_time = $this->microtime_float();
|
||||
$E = new EigenvalueDecomposition($M);
|
||||
$stop_time = $this->microtime_float();
|
||||
$times[] = $stop_time - $start_time;
|
||||
}
|
||||
|
||||
return $times;
|
||||
}
|
||||
|
||||
function runLU($n = 4, $t = 100) {
|
||||
$times = array();
|
||||
|
||||
for( $i = 0; $i < $t; $i++ ) {
|
||||
$M = Matrix::random($n, $n);
|
||||
$start_time = $this->microtime_float();
|
||||
$E = new LUDecomposition($M);
|
||||
$stop_time = $this->microtime_float();
|
||||
$times[] = $stop_time - $start_time;
|
||||
}
|
||||
|
||||
return $times;
|
||||
}
|
||||
|
||||
function runQR($n = 4, $t = 100) {
|
||||
$times = array();
|
||||
|
||||
for( $i = 0; $i < $t; $i++ ) {
|
||||
$M = Matrix::random($n, $n);
|
||||
$start_time = $this->microtime_float();
|
||||
$E = new QRDecomposition($M);
|
||||
$stop_time = $this->microtime_float();
|
||||
$times[] = $stop_time - $start_time;
|
||||
}
|
||||
|
||||
return $times;
|
||||
}
|
||||
|
||||
function runCholesky($n = 4, $t = 100) {
|
||||
$times = array();
|
||||
|
||||
for( $i = 0; $i < $t; $i++ ) {
|
||||
$M = Matrix::random($n, $n);
|
||||
$start_time = $this->microtime_float();
|
||||
$E = new CholeskyDecomposition($M);
|
||||
$stop_time = $this->microtime_float();
|
||||
$times[] = $stop_time - $start_time;
|
||||
}
|
||||
|
||||
return $times;
|
||||
}
|
||||
|
||||
function runSVD($n = 4, $t = 100) {
|
||||
$times = array();
|
||||
|
||||
for( $i = 0; $i < $t; $i++ ) {
|
||||
$M = Matrix::random($n, $n);
|
||||
$start_time = $this->microtime_float();
|
||||
$E = new SingularValueDecomposition($M);
|
||||
$stop_time = $this->microtime_float();
|
||||
$times[] = $stop_time - $start_time;
|
||||
}
|
||||
|
||||
return $times;
|
||||
}
|
||||
|
||||
function run() {
|
||||
|
||||
$n = 8;
|
||||
$t = 16;
|
||||
$sum = 0;
|
||||
echo "<b>Cholesky decomposition: $t random {$n}x{$n} matrices</b><br />";
|
||||
$r = $this->displayStats($this->runCholesky($n, $t));
|
||||
$sum += $r['mean'] * $n;
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
echo "<b>Eigenvalue decomposition: $t random {$n}x{$n} matrices</b><br />";
|
||||
$r = $this->displayStats($this->runEig($n, $t));
|
||||
$sum += $r['mean'] * $n;
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
echo "<b>LU decomposition: $t random {$n}x{$n} matrices</b><br />";
|
||||
$r = $this->displayStats($this->runLU($n, $t));
|
||||
$sum += $r['mean'] * $n;
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
echo "<b>QR decomposition: $t random {$n}x{$n} matrices</b><br />";
|
||||
$r = $this->displayStats($this->runQR($n, $t));
|
||||
$sum += $r['mean'] * $n;
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
echo "<b>Singular Value decomposition: $t random {$n}x{$n} matrices</b><br />";
|
||||
$r = $this->displayStats($this->runSVD($n, $t));
|
||||
$sum += $r['mean'] * $n;
|
||||
|
||||
return $sum;
|
||||
|
||||
}
|
||||
|
||||
} // end MagicSquareExample
|
||||
|
||||
$benchmark = new Benchmark();
|
||||
switch($_REQUEST['decomposition']) {
|
||||
case 'cholesky':
|
||||
$m = array();
|
||||
for($i = 2; $i <= 8; $i *= 2) {
|
||||
$t = 32/$i;
|
||||
echo "<b>Cholesky decomposition: $t random {$i}x{$i} matrices</b><br />";
|
||||
$s = $benchmark->displayStats($benchmark->runCholesky($i, $t));
|
||||
$m[$i] = $s['mean'];
|
||||
echo "<br />";
|
||||
}
|
||||
echo '<pre>';
|
||||
foreach($m as $x => $y)
|
||||
echo "$x\t" . 1000*$y . "\n";
|
||||
echo '</pre>';
|
||||
break;
|
||||
case 'eigenvalue':
|
||||
$m = array();
|
||||
for($i = 2; $i <= 8; $i *= 2) {
|
||||
$t = 32/$i;
|
||||
echo "<b>Eigenvalue decomposition: $t random {$i}x{$i} matrices</b><br />";
|
||||
$s = $benchmark->displayStats($benchmark->runEig($i, $t));
|
||||
$m[$i] = $s['mean'];
|
||||
echo "<br />";
|
||||
}
|
||||
echo '<pre>';
|
||||
foreach($m as $x => $y)
|
||||
echo "$x\t" . 1000*$y . "\n";
|
||||
echo '</pre>';
|
||||
break;
|
||||
case 'lu':
|
||||
$m = array();
|
||||
for($i = 2; $i <= 8; $i *= 2) {
|
||||
$t = 32/$i;
|
||||
echo "<b>LU decomposition: $t random {$i}x{$i} matrices</b><br />";
|
||||
$s = $benchmark->displayStats($benchmark->runLU($i, $t));
|
||||
$m[$i] = $s['mean'];
|
||||
echo "<br />";
|
||||
}
|
||||
echo '<pre>';
|
||||
foreach($m as $x => $y)
|
||||
echo "$x\t" . 1000*$y . "\n";
|
||||
echo '</pre>';
|
||||
break;
|
||||
case 'qr':
|
||||
$m = array();
|
||||
for($i = 2; $i <= 8; $i *= 2) {
|
||||
$t = 32/$i;
|
||||
echo "<b>QR decomposition: $t random {$i}x{$i} matrices</b><br />";
|
||||
$s = $benchmark->displayStats($benchmark->runQR($i, $t));
|
||||
$m[$i] = $s['mean'];
|
||||
echo "<br />";
|
||||
}
|
||||
echo '<pre>';
|
||||
foreach($m as $x => $y)
|
||||
echo "$x\t" . 1000*$y . "\n";
|
||||
echo '</pre>';
|
||||
break;
|
||||
case 'svd':
|
||||
$m = array();
|
||||
for($i = 2; $i <= 8; $i *= 2) {
|
||||
$t = 32/$i;
|
||||
echo "<b>Singular value decomposition: $t random {$i}x{$i} matrices</b><br />";
|
||||
$s = $benchmark->displayStats($benchmark->runSVD($i, $t));
|
||||
$m[$i] = $s['mean'];
|
||||
echo "<br />";
|
||||
}
|
||||
echo '<pre>';
|
||||
foreach($m as $x => $y)
|
||||
echo "$x\t" . 1000*$y . "\n";
|
||||
echo '</pre>';
|
||||
break;
|
||||
case 'all':
|
||||
$s = $benchmark->run();
|
||||
print("<br /><b>Total<b>: {$s}s<br />");
|
||||
break;
|
||||
default:
|
||||
?>
|
||||
<ul>
|
||||
<li><a href="benchmark.php?decomposition=all">Complete Benchmark</a></li>
|
||||
<ul>
|
||||
<li><a href="benchmark.php?decomposition=cholesky">Cholesky</a></li>
|
||||
<li><a href="benchmark.php?decomposition=eigenvalue">Eigenvalue</a></li>
|
||||
<li><a href="benchmark.php?decomposition=lu">LU</a></li>
|
||||
<li><a href="benchmark.php?decomposition=qr">QR</a></li>
|
||||
<li><a href="benchmark.php?decomposition=svd">Singular Value</a></li>
|
||||
</ul>
|
||||
</ul>
|
||||
<?php
|
||||
break;
|
||||
}
|
||||
|
||||
?>
|
||||
73
include/PHPExcel/PHPExcel/Shared/JAMA/examples/polyfit.php
Executable file
73
include/PHPExcel/PHPExcel/Shared/JAMA/examples/polyfit.php
Executable file
@@ -0,0 +1,73 @@
|
||||
<?php
|
||||
require_once "../Matrix.php";
|
||||
/*
|
||||
* @package JAMA
|
||||
* @author Michael Bommarito
|
||||
* @author Paul Meagher
|
||||
* @version 0.1
|
||||
*
|
||||
* Function to fit an order n polynomial function through
|
||||
* a series of x-y data points using least squares.
|
||||
*
|
||||
* @param $X array x values
|
||||
* @param $Y array y values
|
||||
* @param $n int order of polynomial to be used for fitting
|
||||
* @returns array $coeffs of polynomial coefficients
|
||||
* Pre-Conditions: the system is not underdetermined: sizeof($X) > $n+1
|
||||
*/
|
||||
function polyfit($X, $Y, $n) {
|
||||
for ($i = 0; $i < sizeof($X); $i++)
|
||||
for ($j = 0; $j <= $n; $j++)
|
||||
$A[$i][$j] = pow($X[$i], $j);
|
||||
for ($i=0; $i < sizeof($Y); $i++)
|
||||
$B[$i] = array($Y[$i]);
|
||||
$matrixA = new Matrix($A);
|
||||
$matrixB = new Matrix($B);
|
||||
$C = $matrixA->solve($matrixB);
|
||||
return $C->getMatrix(0, $n, 0, 1);
|
||||
}
|
||||
|
||||
function printpoly( $C = null ) {
|
||||
for($i = $C->m - 1; $i >= 0; $i-- ) {
|
||||
$r = $C->get($i, 0);
|
||||
if ( abs($r) <= pow(10, -9) )
|
||||
$r = 0;
|
||||
if ($i == $C->m - 1)
|
||||
echo $r . "x<sup>$i</sup>";
|
||||
else if ($i < $C->m - 1)
|
||||
echo " + " . $r . "x<sup>$i</sup>";
|
||||
else if ($i == 0)
|
||||
echo " + " . $r;
|
||||
}
|
||||
}
|
||||
|
||||
$X = array(0,1,2,3,4,5);
|
||||
$Y = array(4,3,12,67,228, 579);
|
||||
$points = new Matrix(array($X, $Y));
|
||||
$points->toHTML();
|
||||
printpoly(polyfit($X, $Y, 4));
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
$X = array(0,1,2,3,4,5);
|
||||
$Y = array(1,2,5,10,17, 26);
|
||||
$points = new Matrix(array($X, $Y));
|
||||
$points->toHTML();
|
||||
printpoly(polyfit($X, $Y, 2));
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
$X = array(0,1,2,3,4,5,6);
|
||||
$Y = array(-90,-104,-178,-252,-26, 1160, 4446);
|
||||
$points = new Matrix(array($X, $Y));
|
||||
$points->toHTML();
|
||||
printpoly(polyfit($X, $Y, 5));
|
||||
|
||||
echo '<hr />';
|
||||
|
||||
$X = array(0,1,2,3,4);
|
||||
$Y = array(mt_rand(0, 10), mt_rand(40, 80), mt_rand(240, 400), mt_rand(1800, 2215), mt_rand(8000, 9000));
|
||||
$points = new Matrix(array($X, $Y));
|
||||
$points->toHTML();
|
||||
printpoly(polyfit($X, $Y, 3));
|
||||
?>
|
||||
78
include/PHPExcel/PHPExcel/Shared/JAMA/examples/tile.php
Executable file
78
include/PHPExcel/PHPExcel/Shared/JAMA/examples/tile.php
Executable file
@@ -0,0 +1,78 @@
|
||||
<?php
|
||||
|
||||
include "../Matrix.php";
|
||||
|
||||
/**
|
||||
* Tiling of matrix X in [rowWise by colWise] dimension. Tiling
|
||||
* creates a larger matrix than the original data X. Example, if
|
||||
* X is to be tiled in a [3 x 4] manner, then:
|
||||
*
|
||||
* / \
|
||||
* | X X X X |
|
||||
* C = | X X X X |
|
||||
* | X X X X |
|
||||
* \ /
|
||||
*
|
||||
* @param X Matrix
|
||||
* @param rowWise int
|
||||
* @param colWise int
|
||||
* @return Matrix
|
||||
*/
|
||||
|
||||
function tile(&$X, $rowWise, $colWise){
|
||||
|
||||
$xArray = $X->getArray();
|
||||
print_r($xArray);
|
||||
|
||||
$countRow = 0;
|
||||
$countColumn = 0;
|
||||
|
||||
$m = $X->getRowDimension();
|
||||
$n = $X->getColumnDimension();
|
||||
|
||||
if( $rowWise<1 || $colWise<1 ){
|
||||
die("tile : Array index is out-of-bound.");
|
||||
}
|
||||
|
||||
$newRowDim = $m*$rowWise;
|
||||
$newColDim = $n*$colWise;
|
||||
|
||||
$result = array();
|
||||
|
||||
for($i=0 ; $i<$newRowDim; $i++){
|
||||
|
||||
$holder = array();
|
||||
|
||||
for($j=0 ; $j<$newColDim ; $j++){
|
||||
|
||||
$holder[$j] = $xArray[$countRow][$countColumn++];
|
||||
|
||||
// reset the column-index to zero to avoid reference to out-of-bound index in xArray[][]
|
||||
|
||||
if($countColumn == $n) { $countColumn = 0; }
|
||||
|
||||
} // end for
|
||||
|
||||
$countRow++;
|
||||
|
||||
// reset the row-index to zero to avoid reference to out-of-bound index in xArray[][]
|
||||
|
||||
if($countRow == $m) { $countRow = 0; }
|
||||
|
||||
$result[$i] = $holder;
|
||||
|
||||
} // end for
|
||||
|
||||
return new Matrix($result);
|
||||
|
||||
}
|
||||
|
||||
|
||||
$X =array(1,2,3,4,5,6,7,8,9);
|
||||
$nRow = 3;
|
||||
$nCol = 3;
|
||||
$tiled_matrix = tile(new Matrix($X), $nRow, $nCol);
|
||||
echo "<pre>";
|
||||
print_r($tiled_matrix);
|
||||
echo "</pre>";
|
||||
?>
|
||||
415
include/PHPExcel/PHPExcel/Shared/JAMA/tests/TestMatrix.php
Executable file
415
include/PHPExcel/PHPExcel/Shared/JAMA/tests/TestMatrix.php
Executable file
@@ -0,0 +1,415 @@
|
||||
<?php
|
||||
|
||||
require_once "../Matrix.php";
|
||||
|
||||
class TestMatrix {
|
||||
|
||||
function TestMatrix() {
|
||||
|
||||
// define test variables
|
||||
|
||||
$errorCount = 0;
|
||||
$warningCount = 0;
|
||||
$columnwise = array(1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.);
|
||||
$rowwise = array(1.,4.,7.,10.,2.,5.,8.,11.,3.,6.,9.,12.);
|
||||
$avals = array(array(1.,4.,7.,10.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
|
||||
$rankdef = $avals;
|
||||
$tvals = array(array(1.,2.,3.),array(4.,5.,6.),array(7.,8.,9.),array(10.,11.,12.));
|
||||
$subavals = array(array(5.,8.,11.),array(6.,9.,12.));
|
||||
$rvals = array(array(1.,4.,7.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
|
||||
$pvals = array(array(1.,1.,1.),array(1.,2.,3.),array(1.,3.,6.));
|
||||
$ivals = array(array(1.,0.,0.,0.),array(0.,1.,0.,0.),array(0.,0.,1.,0.));
|
||||
$evals = array(array(0.,1.,0.,0.),array(1.,0.,2.e-7,0.),array(0.,-2.e-7,0.,1.),array(0.,0.,1.,0.));
|
||||
$square = array(array(166.,188.,210.),array(188.,214.,240.),array(210.,240.,270.));
|
||||
$sqSolution = array(array(13.),array(15.));
|
||||
$condmat = array(array(1.,3.),array(7.,9.));
|
||||
$rows = 3;
|
||||
$cols = 4;
|
||||
$invalidID = 5; /* should trigger bad shape for construction with val */
|
||||
$raggedr = 0; /* (raggedr,raggedc) should be out of bounds in ragged array */
|
||||
$raggedc = 4;
|
||||
$validID = 3; /* leading dimension of intended test Matrices */
|
||||
$nonconformld = 4; /* leading dimension which is valid, but nonconforming */
|
||||
$ib = 1; /* index ranges for sub Matrix */
|
||||
$ie = 2;
|
||||
$jb = 1;
|
||||
$je = 3;
|
||||
$rowindexset = array(1,2);
|
||||
$badrowindexset = array(1,3);
|
||||
$columnindexset = array(1,2,3);
|
||||
$badcolumnindexset = array(1,2,4);
|
||||
$columnsummax = 33.;
|
||||
$rowsummax = 30.;
|
||||
$sumofdiagonals = 15;
|
||||
$sumofsquares = 650;
|
||||
|
||||
/**
|
||||
* Test matrix methods
|
||||
*/
|
||||
|
||||
/**
|
||||
* Constructors and constructor-like methods:
|
||||
*
|
||||
* Matrix(double[], int)
|
||||
* Matrix(double[][])
|
||||
* Matrix(int, int)
|
||||
* Matrix(int, int, double)
|
||||
* Matrix(int, int, double[][])
|
||||
* constructWithCopy(double[][])
|
||||
* random(int,int)
|
||||
* identity(int)
|
||||
*/
|
||||
echo "<p>Testing constructors and constructor-like methods...</p>";
|
||||
|
||||
$A = new Matrix($columnwise, 3);
|
||||
if( is_a($A, "Matrix") ) {
|
||||
$this->try_success("Column-packed constructor...");
|
||||
} else
|
||||
$errorCount = $this->try_failure($errorCount, "Column-packed constructor...", "Unable to construct Matrix");
|
||||
|
||||
$T = new Matrix($tvals);
|
||||
if( is_a($T, "Matrix") )
|
||||
$this->try_success("2D array constructor...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "2D array constructor...", "Unable to construct Matrix");
|
||||
|
||||
$A = new Matrix($columnwise, $validID);
|
||||
$B = new Matrix($avals);
|
||||
$tmp = $B->get(0,0);
|
||||
$avals[0][0] = 0.0;
|
||||
$C = $B->minus($A);
|
||||
$avals[0][0] = $tmp;
|
||||
$B = Matrix::constructWithCopy($avals);
|
||||
$tmp = $B->get(0,0);
|
||||
$avals[0][0] = 0.0;
|
||||
/** check that constructWithCopy behaves properly **/
|
||||
if ( ( $tmp - $B->get(0,0) ) != 0.0 )
|
||||
$errorCount = $this->try_failure($errorCount,"constructWithCopy... ","copy not effected... data visible outside");
|
||||
else
|
||||
$this->try_success("constructWithCopy... ","");
|
||||
|
||||
$I = new Matrix($ivals);
|
||||
if ( $this->checkMatrices($I,Matrix::identity(3,4)) )
|
||||
$this->try_success("identity... ","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"identity... ","identity Matrix not successfully created");
|
||||
|
||||
/**
|
||||
* Access Methods:
|
||||
*
|
||||
* getColumnDimension()
|
||||
* getRowDimension()
|
||||
* getArray()
|
||||
* getArrayCopy()
|
||||
* getColumnPackedCopy()
|
||||
* getRowPackedCopy()
|
||||
* get(int,int)
|
||||
* getMatrix(int,int,int,int)
|
||||
* getMatrix(int,int,int[])
|
||||
* getMatrix(int[],int,int)
|
||||
* getMatrix(int[],int[])
|
||||
* set(int,int,double)
|
||||
* setMatrix(int,int,int,int,Matrix)
|
||||
* setMatrix(int,int,int[],Matrix)
|
||||
* setMatrix(int[],int,int,Matrix)
|
||||
* setMatrix(int[],int[],Matrix)
|
||||
*/
|
||||
print "<p>Testing access methods...</p>";
|
||||
|
||||
$B = new Matrix($avals);
|
||||
if($B->getRowDimension() == $rows)
|
||||
$this->try_success("getRowDimension...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "getRowDimension...");
|
||||
|
||||
if($B->getColumnDimension() == $cols)
|
||||
$this->try_success("getColumnDimension...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "getColumnDimension...");
|
||||
|
||||
$barray = $B->getArray();
|
||||
if($this->checkArrays($barray, $avals))
|
||||
$this->try_success("getArray...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "getArray...");
|
||||
|
||||
$bpacked = $B->getColumnPackedCopy();
|
||||
if($this->checkArrays($bpacked, $columnwise))
|
||||
$this->try_success("getColumnPackedCopy...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "getColumnPackedCopy...");
|
||||
|
||||
$bpacked = $B->getRowPackedCopy();
|
||||
if($this->checkArrays($bpacked, $rowwise))
|
||||
$this->try_success("getRowPackedCopy...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "getRowPackedCopy...");
|
||||
|
||||
/**
|
||||
* Array-like methods:
|
||||
* minus
|
||||
* minusEquals
|
||||
* plus
|
||||
* plusEquals
|
||||
* arrayLeftDivide
|
||||
* arrayLeftDivideEquals
|
||||
* arrayRightDivide
|
||||
* arrayRightDivideEquals
|
||||
* arrayTimes
|
||||
* arrayTimesEquals
|
||||
* uminus
|
||||
*/
|
||||
print "<p>Testing array-like methods...</p>";
|
||||
|
||||
/**
|
||||
* I/O methods:
|
||||
* read
|
||||
* print
|
||||
* serializable:
|
||||
* writeObject
|
||||
* readObject
|
||||
*/
|
||||
print "<p>Testing I/O methods...</p>";
|
||||
|
||||
/**
|
||||
* Test linear algebra methods
|
||||
*/
|
||||
echo "<p>Testing linear algebra methods...<p>";
|
||||
|
||||
$A = new Matrix($columnwise, 3);
|
||||
if( $this->checkMatrices($A->transpose(), $T) )
|
||||
$this->try_success("Transpose check...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "Transpose check...", "Matrices are not equal");
|
||||
|
||||
if($this->checkScalars($A->norm1(), $columnsummax))
|
||||
$this->try_success("Maximum column sum...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: " . $A->norm1() . " != " . $columnsummax);
|
||||
|
||||
if($this->checkScalars($A->normInf(), $rowsummax))
|
||||
$this->try_success("Maximum row sum...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: " . $A->normInf() . " != " . $rowsummax );
|
||||
|
||||
if($this->checkScalars($A->normF(), sqrt($sumofsquares)))
|
||||
$this->try_success("Frobenius norm...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:" . $A->normF() . " != " . sqrt($sumofsquares));
|
||||
|
||||
if($this->checkScalars($A->trace(), $sumofdiagonals))
|
||||
$this->try_success("Matrix trace...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: " . $A->trace() . " != " . $sumofdiagonals);
|
||||
|
||||
$B = $A->getMatrix(0, $A->getRowDimension(), 0, $A->getRowDimension());
|
||||
if( $B->det() == 0 )
|
||||
$this->try_success("Matrix determinant...");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: " . $B->det() . " != " . 0);
|
||||
|
||||
$A = new Matrix($columnwise,3);
|
||||
$SQ = new Matrix($square);
|
||||
if ($this->checkMatrices($SQ, $A->times($A->transpose())))
|
||||
$this->try_success("times(Matrix)...");
|
||||
else {
|
||||
$errorCount = $this->try_failure($errorCount, "times(Matrix)...", "Unable to multiply matrices");
|
||||
$SQ->toHTML();
|
||||
$AT->toHTML();
|
||||
}
|
||||
|
||||
$A = new Matrix($columnwise, 4);
|
||||
|
||||
$QR = $A->qr();
|
||||
$R = $QR->getR();
|
||||
$Q = $QR->getQ();
|
||||
if($this->checkMatrices($A, $Q->times($R)))
|
||||
$this->try_success("QRDecomposition...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"QRDecomposition...","incorrect qr decomposition calculation");
|
||||
|
||||
$A = new Matrix($columnwise, 4);
|
||||
$SVD = $A->svd();
|
||||
$U = $SVD->getU();
|
||||
$S = $SVD->getS();
|
||||
$V = $SVD->getV();
|
||||
if ($this->checkMatrices($A, $U->times($S->times($V->transpose()))))
|
||||
$this->try_success("SingularValueDecomposition...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
|
||||
|
||||
$n = $A->getColumnDimension();
|
||||
$A = $A->getMatrix(0,$n-1,0,$n-1);
|
||||
$A->set(0,0,0.);
|
||||
|
||||
$LU = $A->lu();
|
||||
$L = $LU->getL();
|
||||
if ( $this->checkMatrices($A->getMatrix($LU->getPivot(),0,$n-1), $L->times($LU->getU())) )
|
||||
$this->try_success("LUDecomposition...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
|
||||
|
||||
$X = $A->inverse();
|
||||
if ( $this->checkMatrices($A->times($X),Matrix::identity(3,3)) )
|
||||
$this->try_success("inverse()...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount, "inverse()...","incorrect inverse calculation");
|
||||
|
||||
$DEF = new Matrix($rankdef);
|
||||
if($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension())-1))
|
||||
$this->try_success("Rank...");
|
||||
else
|
||||
$this->try_failure("Rank...", "incorrect rank calculation");
|
||||
|
||||
$B = new Matrix($condmat);
|
||||
$SVD = $B->svd();
|
||||
$singularvalues = $SVD->getSingularValues();
|
||||
if($this->checkScalars($B->cond(), $singularvalues[0]/$singularvalues[min($B->getRowDimension(), $B->getColumnDimension())-1]))
|
||||
$this->try_success("Condition number...");
|
||||
else
|
||||
$this->try_failure("Condition number...", "incorrect condition number calculation");
|
||||
|
||||
$SUB = new Matrix($subavals);
|
||||
$O = new Matrix($SUB->getRowDimension(),1,1.0);
|
||||
$SOL = new Matrix($sqSolution);
|
||||
$SQ = $SUB->getMatrix(0,$SUB->getRowDimension()-1,0,$SUB->getRowDimension()-1);
|
||||
if ( $this->checkMatrices($SQ->solve($SOL),$O) )
|
||||
$this->try_success("solve()...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"solve()...","incorrect lu solve calculation");
|
||||
|
||||
$A = new Matrix($pvals);
|
||||
$Chol = $A->chol();
|
||||
$L = $Chol->getL();
|
||||
if ( $this->checkMatrices($A, $L->times($L->transpose())) )
|
||||
$this->try_success("CholeskyDecomposition...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
|
||||
|
||||
$X = $Chol->solve(Matrix::identity(3,3));
|
||||
if ( $this->checkMatrices($A->times($X), Matrix::identity(3,3)) )
|
||||
$this->try_success("CholeskyDecomposition solve()...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
|
||||
|
||||
$Eig = $A->eig();
|
||||
$D = $Eig->getD();
|
||||
$V = $Eig->getV();
|
||||
if( $this->checkMatrices($A->times($V),$V->times($D)) )
|
||||
$this->try_success("EigenvalueDecomposition (symmetric)...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
|
||||
|
||||
$A = new Matrix($evals);
|
||||
$Eig = $A->eig();
|
||||
$D = $Eig->getD();
|
||||
$V = $Eig->getV();
|
||||
if ( $this->checkMatrices($A->times($V),$V->times($D)) )
|
||||
$this->try_success("EigenvalueDecomposition (nonsymmetric)...","");
|
||||
else
|
||||
$errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
|
||||
|
||||
print("<b>{$errorCount} total errors</b>.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Print appropriate messages for successful outcome try
|
||||
* @param string $s
|
||||
* @param string $e
|
||||
*/
|
||||
function try_success($s, $e = "") {
|
||||
print "> ". $s ."success<br />";
|
||||
if ($e != "")
|
||||
print "> Message: ". $e ."<br />";
|
||||
}
|
||||
|
||||
/**
|
||||
* Print appropriate messages for unsuccessful outcome try
|
||||
* @param int $count
|
||||
* @param string $s
|
||||
* @param string $e
|
||||
* @return int incremented counter
|
||||
*/
|
||||
function try_failure($count, $s, $e="") {
|
||||
print "> ". $s ."*** failure ***<br />> Message: ". $e ."<br />";
|
||||
return ++$count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Print appropriate messages for unsuccessful outcome try
|
||||
* @param int $count
|
||||
* @param string $s
|
||||
* @param string $e
|
||||
* @return int incremented counter
|
||||
*/
|
||||
function try_warning($count, $s, $e="") {
|
||||
print "> ". $s ."*** warning ***<br />> Message: ". $e ."<br />";
|
||||
return ++$count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check magnitude of difference of "scalars".
|
||||
* @param float $x
|
||||
* @param float $y
|
||||
*/
|
||||
function checkScalars($x, $y) {
|
||||
$eps = pow(2.0,-52.0);
|
||||
if ($x == 0 & abs($y) < 10*$eps) return;
|
||||
if ($y == 0 & abs($x) < 10*$eps) return;
|
||||
if (abs($x-$y) > 10 * $eps * max(abs($x),abs($y)))
|
||||
return false;
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check norm of difference of "vectors".
|
||||
* @param float $x[]
|
||||
* @param float $y[]
|
||||
*/
|
||||
function checkVectors($x, $y) {
|
||||
$nx = count($x);
|
||||
$ny = count($y);
|
||||
if ($nx == $ny)
|
||||
for($i=0; $i < $nx; $i++)
|
||||
$this->checkScalars($x[$i],$y[$i]);
|
||||
else
|
||||
die("Attempt to compare vectors of different lengths");
|
||||
}
|
||||
|
||||
/**
|
||||
* Check norm of difference of "arrays".
|
||||
* @param float $x[][]
|
||||
* @param float $y[][]
|
||||
*/
|
||||
function checkArrays($x, $y) {
|
||||
$A = new Matrix($x);
|
||||
$B = new Matrix($y);
|
||||
return $this->checkMatrices($A,$B);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check norm of difference of "matrices".
|
||||
* @param matrix $X
|
||||
* @param matrix $Y
|
||||
*/
|
||||
function checkMatrices($X = null, $Y = null) {
|
||||
if( $X == null || $Y == null )
|
||||
return false;
|
||||
|
||||
$eps = pow(2.0,-52.0);
|
||||
if ($X->norm1() == 0. & $Y->norm1() < 10*$eps) return true;
|
||||
if ($Y->norm1() == 0. & $X->norm1() < 10*$eps) return true;
|
||||
|
||||
$A = $X->minus($Y);
|
||||
|
||||
if ($A->norm1() > 1000 * $eps * max($X->norm1(),$Y->norm1()))
|
||||
die("The norm of (X-Y) is too large: ".$A->norm1());
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
$test = new TestMatrix;
|
||||
?>
|
||||
120
include/PHPExcel/PHPExcel/Shared/JAMA/utils/Error.php
Executable file
120
include/PHPExcel/PHPExcel/Shared/JAMA/utils/Error.php
Executable file
@@ -0,0 +1,120 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* Error handling
|
||||
* @author Michael Bommarito
|
||||
* @version 01292005
|
||||
*/
|
||||
|
||||
//Language constant
|
||||
define('LANG', 'EN');
|
||||
|
||||
|
||||
//Error type constants
|
||||
define('ERROR', E_USER_ERROR);
|
||||
define('WARNING', E_USER_WARNING);
|
||||
define('NOTICE', E_USER_NOTICE);
|
||||
|
||||
//All errors may be defined by the following format:
|
||||
//define('ExceptionName', N);
|
||||
//$error['lang'][N] = 'Error message';
|
||||
$error = array();
|
||||
|
||||
/*
|
||||
I've used Babelfish and a little poor knowledge of Romance/Germanic languages for the translations
|
||||
here. Feel free to correct anything that looks amiss to you.
|
||||
*/
|
||||
|
||||
define('PolymorphicArgumentException', -1);
|
||||
$error['EN'][-1] = "Invalid argument pattern for polymorphic function.";
|
||||
$error['FR'][-1] = "Modèle inadmissible d'argument pour la fonction polymorphe.".
|
||||
$error['DE'][-1] = "Unzulässiges Argumentmuster für polymorphe Funktion.";
|
||||
|
||||
define('ArgumentTypeException', -2);
|
||||
$error['EN'][-2] = "Invalid argument type.";
|
||||
$error['FR'][-2] = "Type inadmissible d'argument.";
|
||||
$error['DE'][-2] = "Unzulässige Argumentart.";
|
||||
|
||||
define('ArgumentBoundsException', -3);
|
||||
$error['EN'][-3] = "Invalid argument range.";
|
||||
$error['FR'][-3] = "Gamme inadmissible d'argument.";
|
||||
$error['DE'][-3] = "Unzulässige Argumentstrecke.";
|
||||
|
||||
define('MatrixDimensionException', -4);
|
||||
$error['EN'][-4] = "Matrix dimensions are not equal.";
|
||||
$error['FR'][-4] = "Les dimensions de Matrix ne sont pas égales.";
|
||||
$error['DE'][-4] = "Matrixmaße sind nicht gleich.";
|
||||
|
||||
define('PrecisionLossException', -5);
|
||||
$error['EN'][-5] = "Significant precision loss detected.";
|
||||
$error['FR'][-5] = "Perte significative de précision détectée.";
|
||||
$error['DE'][-5] = "Bedeutender Präzision Verlust ermittelte.";
|
||||
|
||||
define('MatrixSPDException', -6);
|
||||
$error['EN'][-6] = "Can only perform operation on symmetric positive definite matrix.";
|
||||
$error['FR'][-6] = "Perte significative de précision détectée.";
|
||||
$error['DE'][-6] = "Bedeutender Präzision Verlust ermittelte.";
|
||||
|
||||
define('MatrixSingularException', -7);
|
||||
$error['EN'][-7] = "Can only perform operation on singular matrix.";
|
||||
|
||||
define('MatrixRankException', -8);
|
||||
$error['EN'][-8] = "Can only perform operation on full-rank matrix.";
|
||||
|
||||
define('ArrayLengthException', -9);
|
||||
$error['EN'][-9] = "Array length must be a multiple of m.";
|
||||
|
||||
define('RowLengthException', -10);
|
||||
$error['EN'][-10] = "All rows must have the same length.";
|
||||
|
||||
/**
|
||||
* Custom error handler
|
||||
* @param int $type Error type: {ERROR, WARNING, NOTICE}
|
||||
* @param int $num Error number
|
||||
* @param string $file File in which the error occured
|
||||
* @param int $line Line on which the error occured
|
||||
*/
|
||||
function JAMAError( $type = null, $num = null, $file = null, $line = null, $context = null ) {
|
||||
global $error;
|
||||
|
||||
$lang = LANG;
|
||||
if( isset($type) && isset($num) && isset($file) && isset($line) ) {
|
||||
switch( $type ) {
|
||||
case ERROR:
|
||||
echo '<div class="errror"><b>Error:</b> ' . $error[$lang][$num] . '<br />' . $file . ' @ L' . $line . '</div>';
|
||||
die();
|
||||
break;
|
||||
|
||||
case WARNING:
|
||||
echo '<div class="warning"><b>Warning:</b> ' . $error[$lang][$num] . '<br />' . $file . ' @ L' . $line . '</div>';
|
||||
break;
|
||||
|
||||
case NOTICE:
|
||||
//echo '<div class="notice"><b>Notice:</b> ' . $error[$lang][$num] . '<br />' . $file . ' @ L' . $line . '</div>';
|
||||
break;
|
||||
|
||||
case E_NOTICE:
|
||||
//echo '<div class="errror"><b>Notice:</b> ' . $error[$lang][$num] . '<br />' . $file . ' @ L' . $line . '</div>';
|
||||
break;
|
||||
|
||||
case E_STRICT:
|
||||
break;
|
||||
|
||||
case E_WARNING:
|
||||
break;
|
||||
|
||||
default:
|
||||
echo "<div class=\"error\"><b>Unknown Error Type:</b> $type - $file @ L{$line}</div>";
|
||||
die();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
die( "Invalid arguments to JAMAError()" );
|
||||
}
|
||||
}
|
||||
|
||||
// TODO MarkBaker
|
||||
//set_error_handler('JAMAError');
|
||||
//error_reporting(ERROR | WARNING);
|
||||
|
||||
40
include/PHPExcel/PHPExcel/Shared/JAMA/utils/Maths.php
Executable file
40
include/PHPExcel/PHPExcel/Shared/JAMA/utils/Maths.php
Executable file
@@ -0,0 +1,40 @@
|
||||
<?php
|
||||
/**
|
||||
* @package JAMA
|
||||
*
|
||||
* Pythagorean Theorem:
|
||||
*
|
||||
* a = 3
|
||||
* b = 4
|
||||
* r = sqrt(square(a) + square(b))
|
||||
* r = 5
|
||||
*
|
||||
* r = sqrt(a^2 + b^2) without under/overflow.
|
||||
*/
|
||||
function hypo($a, $b) {
|
||||
if (abs($a) > abs($b)) {
|
||||
$r = $b/$a;
|
||||
$r = abs($a)* sqrt(1+$r*$r);
|
||||
} else if ($b != 0) {
|
||||
$r = $a/$b;
|
||||
$r = abs($b)*sqrt(1+$r*$r);
|
||||
} else
|
||||
$r = 0.0;
|
||||
return $r;
|
||||
}
|
||||
|
||||
/**
|
||||
* Mike Bommarito's version.
|
||||
* Compute n-dimensional hyotheneuse.
|
||||
*
|
||||
function hypot() {
|
||||
$s = 0;
|
||||
foreach (func_get_args() as $d) {
|
||||
if (is_numeric($d))
|
||||
$s += pow($d, 2);
|
||||
else
|
||||
trigger_error(ArgumentTypeException, ERROR);
|
||||
}
|
||||
return sqrt($s);
|
||||
}
|
||||
*/
|
||||
547
include/PHPExcel/PHPExcel/Shared/OLE.php
Executable file
547
include/PHPExcel/PHPExcel/Shared/OLE.php
Executable file
@@ -0,0 +1,547 @@
|
||||
<?php
|
||||
/* vim: set expandtab tabstop=4 shiftwidth=4: */
|
||||
// +----------------------------------------------------------------------+
|
||||
// | PHP Version 4 |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Copyright (c) 1997-2002 The PHP Group |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | This source file is subject to version 2.02 of the PHP license, |
|
||||
// | that is bundled with this package in the file LICENSE, and is |
|
||||
// | available at through the world-wide-web at |
|
||||
// | http://www.php.net/license/2_02.txt. |
|
||||
// | If you did not receive a copy of the PHP license and are unable to |
|
||||
// | obtain it through the world-wide-web, please send a note to |
|
||||
// | license@php.net so we can mail you a copy immediately. |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Author: Xavier Noguer <xnoguer@php.net> |
|
||||
// | Based on OLE::Storage_Lite by Kawai, Takanori |
|
||||
// +----------------------------------------------------------------------+
|
||||
//
|
||||
// $Id: OLE.php,v 1.13 2007/03/07 14:38:25 schmidt Exp $
|
||||
|
||||
require_once 'PHPExcel/Shared/OLE.php';
|
||||
require_once 'PHPExcel/Shared/OLE/OLE_PPS.php';
|
||||
require_once 'PHPExcel/Shared/OLE/OLE_File.php';
|
||||
require_once 'PHPExcel/Shared/OLE/OLE_Root.php';
|
||||
require_once 'PHPExcel/Shared/OLE/ChainedBlockStream.php';
|
||||
|
||||
/**
|
||||
* Array for storing OLE instances that are accessed from
|
||||
* OLE_ChainedBlockStream::stream_open().
|
||||
* @var array
|
||||
*/
|
||||
$GLOBALS['_OLE_INSTANCES'] = array();
|
||||
|
||||
/**
|
||||
* OLE package base class.
|
||||
*
|
||||
* @author Xavier Noguer <xnoguer@php.net>
|
||||
* @author Christian Schmidt <schmidt@php.net>
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_OLE
|
||||
*/
|
||||
class PHPExcel_Shared_OLE
|
||||
{
|
||||
const OLE_PPS_TYPE_ROOT = 5;
|
||||
const OLE_PPS_TYPE_DIR = 1;
|
||||
const OLE_PPS_TYPE_FILE = 2;
|
||||
const OLE_DATA_SIZE_SMALL = 0x1000;
|
||||
const OLE_LONG_INT_SIZE = 4;
|
||||
const OLE_PPS_SIZE = 0x80;
|
||||
|
||||
/**
|
||||
* The file handle for reading an OLE container
|
||||
* @var resource
|
||||
*/
|
||||
public $_file_handle;
|
||||
|
||||
/**
|
||||
* Array of PPS's found on the OLE container
|
||||
* @var array
|
||||
*/
|
||||
public $_list = array();
|
||||
|
||||
/**
|
||||
* Root directory of OLE container
|
||||
* @var OLE_PPS_Root
|
||||
*/
|
||||
public $root;
|
||||
|
||||
/**
|
||||
* Big Block Allocation Table
|
||||
* @var array (blockId => nextBlockId)
|
||||
*/
|
||||
public $bbat;
|
||||
|
||||
/**
|
||||
* Short Block Allocation Table
|
||||
* @var array (blockId => nextBlockId)
|
||||
*/
|
||||
public $sbat;
|
||||
|
||||
/**
|
||||
* Size of big blocks. This is usually 512.
|
||||
* @var int number of octets per block.
|
||||
*/
|
||||
public $bigBlockSize;
|
||||
|
||||
/**
|
||||
* Size of small blocks. This is usually 64.
|
||||
* @var int number of octets per block
|
||||
*/
|
||||
public $smallBlockSize;
|
||||
|
||||
/**
|
||||
* Reads an OLE container from the contents of the file given.
|
||||
*
|
||||
* @acces public
|
||||
* @param string $file
|
||||
* @return mixed true on success, PEAR_Error on failure
|
||||
*/
|
||||
public function read($file)
|
||||
{
|
||||
$fh = fopen($file, "r");
|
||||
if (!$fh) {
|
||||
throw new Exception("Can't open file $file");
|
||||
}
|
||||
$this->_file_handle = $fh;
|
||||
|
||||
$signature = fread($fh, 8);
|
||||
if ("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1" != $signature) {
|
||||
throw new Exception("File doesn't seem to be an OLE container.");
|
||||
}
|
||||
fseek($fh, 28);
|
||||
if (fread($fh, 2) != "\xFE\xFF") {
|
||||
// This shouldn't be a problem in practice
|
||||
throw new Exception("Only Little-Endian encoding is supported.");
|
||||
}
|
||||
// Size of blocks and short blocks in bytes
|
||||
$this->bigBlockSize = pow(2, $this->_readInt2($fh));
|
||||
$this->smallBlockSize = pow(2, $this->_readInt2($fh));
|
||||
|
||||
// Skip UID, revision number and version number
|
||||
fseek($fh, 44);
|
||||
// Number of blocks in Big Block Allocation Table
|
||||
$bbatBlockCount = $this->_readInt4($fh);
|
||||
|
||||
// Root chain 1st block
|
||||
$directoryFirstBlockId = $this->_readInt4($fh);
|
||||
|
||||
// Skip unused bytes
|
||||
fseek($fh, 56);
|
||||
// Streams shorter than this are stored using small blocks
|
||||
$this->bigBlockThreshold = $this->_readInt4($fh);
|
||||
// Block id of first sector in Short Block Allocation Table
|
||||
$sbatFirstBlockId = $this->_readInt4($fh);
|
||||
// Number of blocks in Short Block Allocation Table
|
||||
$sbbatBlockCount = $this->_readInt4($fh);
|
||||
// Block id of first sector in Master Block Allocation Table
|
||||
$mbatFirstBlockId = $this->_readInt4($fh);
|
||||
// Number of blocks in Master Block Allocation Table
|
||||
$mbbatBlockCount = $this->_readInt4($fh);
|
||||
$this->bbat = array();
|
||||
|
||||
// Remaining 4 * 109 bytes of current block is beginning of Master
|
||||
// Block Allocation Table
|
||||
$mbatBlocks = array();
|
||||
for ($i = 0; $i < 109; ++$i) {
|
||||
$mbatBlocks[] = $this->_readInt4($fh);
|
||||
}
|
||||
|
||||
// Read rest of Master Block Allocation Table (if any is left)
|
||||
$pos = $this->_getBlockOffset($mbatFirstBlockId);
|
||||
for ($i = 0; $i < $mbbatBlockCount; ++$i) {
|
||||
fseek($fh, $pos);
|
||||
for ($j = 0; $j < $this->bigBlockSize / 4 - 1; ++$j) {
|
||||
$mbatBlocks[] = $this->_readInt4($fh);
|
||||
}
|
||||
// Last block id in each block points to next block
|
||||
$pos = $this->_getBlockOffset($this->_readInt4($fh));
|
||||
}
|
||||
|
||||
// Read Big Block Allocation Table according to chain specified by
|
||||
// $mbatBlocks
|
||||
for ($i = 0; $i < $bbatBlockCount; ++$i) {
|
||||
$pos = $this->_getBlockOffset($mbatBlocks[$i]);
|
||||
fseek($fh, $pos);
|
||||
for ($j = 0 ; $j < $this->bigBlockSize / 4; ++$j) {
|
||||
$this->bbat[] = $this->_readInt4($fh);
|
||||
}
|
||||
}
|
||||
|
||||
// Read short block allocation table (SBAT)
|
||||
$this->sbat = array();
|
||||
$shortBlockCount = $sbbatBlockCount * $this->bigBlockSize / 4;
|
||||
$sbatFh = $this->getStream($sbatFirstBlockId);
|
||||
for ($blockId = 0; $blockId < $shortBlockCount; ++$blockId) {
|
||||
$this->sbat[$blockId] = $this->_readInt4($sbatFh);
|
||||
}
|
||||
fclose($sbatFh);
|
||||
|
||||
$this->_readPpsWks($directoryFirstBlockId);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int block id
|
||||
* @param int byte offset from beginning of file
|
||||
* @access public
|
||||
*/
|
||||
public function _getBlockOffset($blockId)
|
||||
{
|
||||
return 512 + $blockId * $this->bigBlockSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a stream for use with fread() etc. External callers should
|
||||
* use PHPExcel_Shared_OLE_PPS_File::getStream().
|
||||
* @param int|PPS block id or PPS
|
||||
* @return resource read-only stream
|
||||
*/
|
||||
public function getStream($blockIdOrPps)
|
||||
{
|
||||
static $isRegistered = false;
|
||||
if (!$isRegistered) {
|
||||
stream_wrapper_register('ole-chainedblockstream',
|
||||
'PHPExcel_Shared_OLE_ChainedBlockStream');
|
||||
$isRegistered = true;
|
||||
}
|
||||
|
||||
// Store current instance in global array, so that it can be accessed
|
||||
// in OLE_ChainedBlockStream::stream_open().
|
||||
// Object is removed from self::$instances in OLE_Stream::close().
|
||||
$GLOBALS['_OLE_INSTANCES'][] = $this;
|
||||
$instanceId = end(array_keys($GLOBALS['_OLE_INSTANCES']));
|
||||
|
||||
$path = 'ole-chainedblockstream://oleInstanceId=' . $instanceId;
|
||||
if ($blockIdOrPps instanceof PHPExcel_Shared_OLE_PPS) {
|
||||
$path .= '&blockId=' . $blockIdOrPps->_StartBlock;
|
||||
$path .= '&size=' . $blockIdOrPps->Size;
|
||||
} else {
|
||||
$path .= '&blockId=' . $blockIdOrPps;
|
||||
}
|
||||
return fopen($path, 'r');
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads a signed char.
|
||||
* @param resource file handle
|
||||
* @return int
|
||||
* @access public
|
||||
*/
|
||||
public function _readInt1($fh)
|
||||
{
|
||||
list(, $tmp) = unpack("c", fread($fh, 1));
|
||||
return $tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads an unsigned short (2 octets).
|
||||
* @param resource file handle
|
||||
* @return int
|
||||
* @access public
|
||||
*/
|
||||
public function _readInt2($fh)
|
||||
{
|
||||
list(, $tmp) = unpack("v", fread($fh, 2));
|
||||
return $tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads an unsigned long (4 octets).
|
||||
* @param resource file handle
|
||||
* @return int
|
||||
* @access public
|
||||
*/
|
||||
public function _readInt4($fh)
|
||||
{
|
||||
list(, $tmp) = unpack("V", fread($fh, 4));
|
||||
return $tmp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets information about all PPS's on the OLE container from the PPS WK's
|
||||
* creates an OLE_PPS object for each one.
|
||||
*
|
||||
* @access public
|
||||
* @param integer the block id of the first block
|
||||
* @return mixed true on success, PEAR_Error on failure
|
||||
*/
|
||||
public function _readPpsWks($blockId)
|
||||
{
|
||||
$fh = $this->getStream($blockId);
|
||||
for ($pos = 0; ; $pos += 128) {
|
||||
fseek($fh, $pos, SEEK_SET);
|
||||
$nameUtf16 = fread($fh, 64);
|
||||
$nameLength = $this->_readInt2($fh);
|
||||
$nameUtf16 = substr($nameUtf16, 0, $nameLength - 2);
|
||||
// Simple conversion from UTF-16LE to ISO-8859-1
|
||||
$name = str_replace("\x00", "", $nameUtf16);
|
||||
$type = $this->_readInt1($fh);
|
||||
switch ($type) {
|
||||
case self::OLE_PPS_TYPE_ROOT:
|
||||
$pps = new PHPExcel_Shared_OLE_PPS_Root(null, null, array());
|
||||
$this->root = $pps;
|
||||
break;
|
||||
case self::OLE_PPS_TYPE_DIR:
|
||||
$pps = new PHPExcel_Shared_OLE_PPS(null, null, null, null, null,
|
||||
null, null, null, null, array());
|
||||
break;
|
||||
case self::OLE_PPS_TYPE_FILE:
|
||||
$pps = new PHPExcel_Shared_OLE_PPS_File($name);
|
||||
break;
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
fseek($fh, 1, SEEK_CUR);
|
||||
$pps->Type = $type;
|
||||
$pps->Name = $name;
|
||||
$pps->PrevPps = $this->_readInt4($fh);
|
||||
$pps->NextPps = $this->_readInt4($fh);
|
||||
$pps->DirPps = $this->_readInt4($fh);
|
||||
fseek($fh, 20, SEEK_CUR);
|
||||
$pps->Time1st = self::OLE2LocalDate(fread($fh, 8));
|
||||
$pps->Time2nd = self::OLE2LocalDate(fread($fh, 8));
|
||||
$pps->_StartBlock = $this->_readInt4($fh);
|
||||
$pps->Size = $this->_readInt4($fh);
|
||||
$pps->No = count($this->_list);
|
||||
$this->_list[] = $pps;
|
||||
|
||||
// check if the PPS tree (starting from root) is complete
|
||||
if (isset($this->root) &&
|
||||
$this->_ppsTreeComplete($this->root->No)) {
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
fclose($fh);
|
||||
|
||||
// Initialize $pps->children on directories
|
||||
foreach ($this->_list as $pps) {
|
||||
if ($pps->Type == self::OLE_PPS_TYPE_DIR || $pps->Type == self::OLE_PPS_TYPE_ROOT) {
|
||||
$nos = array($pps->DirPps);
|
||||
$pps->children = array();
|
||||
while ($nos) {
|
||||
$no = array_pop($nos);
|
||||
if ($no != -1) {
|
||||
$childPps = $this->_list[$no];
|
||||
$nos[] = $childPps->PrevPps;
|
||||
$nos[] = $childPps->NextPps;
|
||||
$pps->children[] = $childPps;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* It checks whether the PPS tree is complete (all PPS's read)
|
||||
* starting with the given PPS (not necessarily root)
|
||||
*
|
||||
* @access public
|
||||
* @param integer $index The index of the PPS from which we are checking
|
||||
* @return boolean Whether the PPS tree for the given PPS is complete
|
||||
*/
|
||||
public function _ppsTreeComplete($index)
|
||||
{
|
||||
return isset($this->_list[$index]) &&
|
||||
($pps = $this->_list[$index]) &&
|
||||
($pps->PrevPps == -1 ||
|
||||
$this->_ppsTreeComplete($pps->PrevPps)) &&
|
||||
($pps->NextPps == -1 ||
|
||||
$this->_ppsTreeComplete($pps->NextPps)) &&
|
||||
($pps->DirPps == -1 ||
|
||||
$this->_ppsTreeComplete($pps->DirPps));
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether a PPS is a File PPS or not.
|
||||
* If there is no PPS for the index given, it will return false.
|
||||
*
|
||||
* @access public
|
||||
* @param integer $index The index for the PPS
|
||||
* @return bool true if it's a File PPS, false otherwise
|
||||
*/
|
||||
public function isFile($index)
|
||||
{
|
||||
if (isset($this->_list[$index])) {
|
||||
return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_FILE);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks whether a PPS is a Root PPS or not.
|
||||
* If there is no PPS for the index given, it will return false.
|
||||
*
|
||||
* @access public
|
||||
* @param integer $index The index for the PPS.
|
||||
* @return bool true if it's a Root PPS, false otherwise
|
||||
*/
|
||||
public function isRoot($index)
|
||||
{
|
||||
if (isset($this->_list[$index])) {
|
||||
return ($this->_list[$index]->Type == self::OLE_PPS_TYPE_ROOT);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gives the total number of PPS's found in the OLE container.
|
||||
*
|
||||
* @access public
|
||||
* @return integer The total number of PPS's found in the OLE container
|
||||
*/
|
||||
public function ppsTotal()
|
||||
{
|
||||
return count($this->_list);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets data from a PPS
|
||||
* If there is no PPS for the index given, it will return an empty string.
|
||||
*
|
||||
* @access public
|
||||
* @param integer $index The index for the PPS
|
||||
* @param integer $position The position from which to start reading
|
||||
* (relative to the PPS)
|
||||
* @param integer $length The amount of bytes to read (at most)
|
||||
* @return string The binary string containing the data requested
|
||||
* @see OLE_PPS_File::getStream()
|
||||
*/
|
||||
public function getData($index, $position, $length)
|
||||
{
|
||||
// if position is not valid return empty string
|
||||
if (!isset($this->_list[$index]) || ($position >= $this->_list[$index]->Size) || ($position < 0)) {
|
||||
return '';
|
||||
}
|
||||
$fh = $this->getStream($this->_list[$index]);
|
||||
$data = stream_get_contents($fh, $length, $position);
|
||||
fclose($fh);
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the data length from a PPS
|
||||
* If there is no PPS for the index given, it will return 0.
|
||||
*
|
||||
* @access public
|
||||
* @param integer $index The index for the PPS
|
||||
* @return integer The amount of bytes in data the PPS has
|
||||
*/
|
||||
public function getDataLength($index)
|
||||
{
|
||||
if (isset($this->_list[$index])) {
|
||||
return $this->_list[$index]->Size;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to transform ASCII text to Unicode
|
||||
*
|
||||
* @access public
|
||||
* @static
|
||||
* @param string $ascii The ASCII string to transform
|
||||
* @return string The string in Unicode
|
||||
*/
|
||||
public static function Asc2Ucs($ascii)
|
||||
{
|
||||
$rawname = '';
|
||||
for ($i = 0; $i < strlen($ascii); ++$i) {
|
||||
$rawname .= $ascii{$i} . "\x00";
|
||||
}
|
||||
return $rawname;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function
|
||||
* Returns a string for the OLE container with the date given
|
||||
*
|
||||
* @access public
|
||||
* @static
|
||||
* @param integer $date A timestamp
|
||||
* @return string The string for the OLE container
|
||||
*/
|
||||
public static function LocalDate2OLE($date = null)
|
||||
{
|
||||
if (!isset($date)) {
|
||||
return "\x00\x00\x00\x00\x00\x00\x00\x00";
|
||||
}
|
||||
|
||||
// factor used for separating numbers into 4 bytes parts
|
||||
$factor = pow(2, 32);
|
||||
|
||||
// days from 1-1-1601 until the beggining of UNIX era
|
||||
$days = 134774;
|
||||
// calculate seconds
|
||||
$big_date = $days*24*3600 + gmmktime(date("H",$date),date("i",$date),date("s",$date),
|
||||
date("m",$date),date("d",$date),date("Y",$date));
|
||||
// multiply just to make MS happy
|
||||
$big_date *= 10000000;
|
||||
|
||||
$high_part = floor($big_date / $factor);
|
||||
// lower 4 bytes
|
||||
$low_part = floor((($big_date / $factor) - $high_part) * $factor);
|
||||
|
||||
// Make HEX string
|
||||
$res = '';
|
||||
|
||||
for ($i = 0; $i < 4; ++$i) {
|
||||
$hex = $low_part % 0x100;
|
||||
$res .= pack('c', $hex);
|
||||
$low_part /= 0x100;
|
||||
}
|
||||
for ($i = 0; $i < 4; ++$i) {
|
||||
$hex = $high_part % 0x100;
|
||||
$res .= pack('c', $hex);
|
||||
$high_part /= 0x100;
|
||||
}
|
||||
return $res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a timestamp from an OLE container's date
|
||||
*
|
||||
* @access public
|
||||
* @static
|
||||
* @param integer $string A binary string with the encoded date
|
||||
* @return string The timestamp corresponding to the string
|
||||
*/
|
||||
public static function OLE2LocalDate($string)
|
||||
{
|
||||
if (strlen($string) != 8) {
|
||||
return new PEAR_Error("Expecting 8 byte string");
|
||||
}
|
||||
|
||||
// factor used for separating numbers into 4 bytes parts
|
||||
$factor = pow(2,32);
|
||||
$high_part = 0;
|
||||
for ($i = 0; $i < 4; ++$i) {
|
||||
list(, $high_part) = unpack('C', $string{(7 - $i)});
|
||||
if ($i < 3) {
|
||||
$high_part *= 0x100;
|
||||
}
|
||||
}
|
||||
$low_part = 0;
|
||||
for ($i = 4; $i < 8; ++$i) {
|
||||
list(, $low_part) = unpack('C', $string{(7 - $i)});
|
||||
if ($i < 7) {
|
||||
$low_part *= 0x100;
|
||||
}
|
||||
}
|
||||
$big_date = ($high_part * $factor) + $low_part;
|
||||
// translate to seconds
|
||||
$big_date /= 10000000;
|
||||
|
||||
// days from 1-1-1601 until the beggining of UNIX era
|
||||
$days = 134774;
|
||||
|
||||
// translate to seconds from beggining of UNIX era
|
||||
$big_date -= $days * 24 * 3600;
|
||||
return floor($big_date);
|
||||
}
|
||||
}
|
||||
226
include/PHPExcel/PHPExcel/Shared/OLE/ChainedBlockStream.php
Executable file
226
include/PHPExcel/PHPExcel/Shared/OLE/ChainedBlockStream.php
Executable file
@@ -0,0 +1,226 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (C) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_OLE
|
||||
* @copyright Copyright (c) 2006 - 2007 Christian Schmidt
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
require_once 'PHPExcel/Shared/OLE.php';
|
||||
|
||||
/**
|
||||
* PHPExcel_Shared_OLE_ChainedBlockStream
|
||||
*
|
||||
* Stream wrapper for reading data stored in an OLE file. Implements methods
|
||||
* for PHP's stream_wrapper_register(). For creating streams using this
|
||||
* wrapper, use PHPExcel_Shared_OLE_PPS_File::getStream().
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_OLE
|
||||
*/
|
||||
class PHPExcel_Shared_OLE_ChainedBlockStream
|
||||
{
|
||||
/**
|
||||
* The OLE container of the file that is being read.
|
||||
* @var OLE
|
||||
*/
|
||||
public $ole;
|
||||
|
||||
/**
|
||||
* Parameters specified by fopen().
|
||||
* @var array
|
||||
*/
|
||||
public $params;
|
||||
|
||||
/**
|
||||
* The binary data of the file.
|
||||
* @var string
|
||||
*/
|
||||
public $data;
|
||||
|
||||
/**
|
||||
* The file pointer.
|
||||
* @var int byte offset
|
||||
*/
|
||||
public $pos;
|
||||
|
||||
/**
|
||||
* Implements support for fopen().
|
||||
* For creating streams using this wrapper, use OLE_PPS_File::getStream().
|
||||
* @param string resource name including scheme, e.g.
|
||||
* ole-chainedblockstream://oleInstanceId=1
|
||||
* @param string only "r" is supported
|
||||
* @param int mask of STREAM_REPORT_ERRORS and STREAM_USE_PATH
|
||||
* @param string absolute path of the opened stream (out parameter)
|
||||
* @return bool true on success
|
||||
*/
|
||||
public function stream_open($path, $mode, $options, &$openedPath)
|
||||
{
|
||||
if ($mode != 'r') {
|
||||
if ($options & STREAM_REPORT_ERRORS) {
|
||||
trigger_error('Only reading is supported', E_USER_WARNING);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// 25 is length of "ole-chainedblockstream://"
|
||||
parse_str(substr($path, 25), $this->params);
|
||||
if (!isset($this->params['oleInstanceId'],
|
||||
$this->params['blockId'],
|
||||
$GLOBALS['_OLE_INSTANCES'][$this->params['oleInstanceId']])) {
|
||||
|
||||
if ($options & STREAM_REPORT_ERRORS) {
|
||||
trigger_error('OLE stream not found', E_USER_WARNING);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
$this->ole = $GLOBALS['_OLE_INSTANCES'][$this->params['oleInstanceId']];
|
||||
|
||||
$blockId = $this->params['blockId'];
|
||||
$this->data = '';
|
||||
if (isset($this->params['size']) &&
|
||||
$this->params['size'] < $this->ole->bigBlockThreshold &&
|
||||
$blockId != $this->ole->root->_StartBlock) {
|
||||
|
||||
// Block id refers to small blocks
|
||||
$rootPos = $this->ole->_getBlockOffset($this->ole->root->_StartBlock);
|
||||
while ($blockId != -2) {
|
||||
$pos = $rootPos + $blockId * $this->ole->bigBlockSize;
|
||||
$blockId = $this->ole->sbat[$blockId];
|
||||
fseek($this->ole->_file_handle, $pos);
|
||||
$this->data .= fread($this->ole->_file_handle, $this->ole->bigBlockSize);
|
||||
}
|
||||
} else {
|
||||
// Block id refers to big blocks
|
||||
while ($blockId != -2) {
|
||||
$pos = $this->ole->_getBlockOffset($blockId);
|
||||
fseek($this->ole->_file_handle, $pos);
|
||||
$this->data .= fread($this->ole->_file_handle, $this->ole->bigBlockSize);
|
||||
$blockId = $this->ole->bbat[$blockId];
|
||||
}
|
||||
}
|
||||
if (isset($this->params['size'])) {
|
||||
$this->data = substr($this->data, 0, $this->params['size']);
|
||||
}
|
||||
|
||||
if ($options & STREAM_USE_PATH) {
|
||||
$openedPath = $path;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements support for fclose().
|
||||
* @return string
|
||||
*/
|
||||
public function stream_close()
|
||||
{
|
||||
$this->ole = null;
|
||||
unset($GLOBALS['_OLE_INSTANCES']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements support for fread(), fgets() etc.
|
||||
* @param int maximum number of bytes to read
|
||||
* @return string
|
||||
*/
|
||||
public function stream_read($count)
|
||||
{
|
||||
if ($this->stream_eof()) {
|
||||
return false;
|
||||
}
|
||||
$s = substr($this->data, $this->pos, $count);
|
||||
$this->pos += $count;
|
||||
return $s;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements support for feof().
|
||||
* @return bool TRUE if the file pointer is at EOF; otherwise FALSE
|
||||
*/
|
||||
public function stream_eof()
|
||||
{
|
||||
$eof = $this->pos >= strlen($this->data);
|
||||
// Workaround for bug in PHP 5.0.x: http://bugs.php.net/27508
|
||||
if (version_compare(PHP_VERSION, '5.0', '>=') &&
|
||||
version_compare(PHP_VERSION, '5.1', '<')) {
|
||||
|
||||
$eof = !$eof;
|
||||
}
|
||||
return $eof;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the position of the file pointer, i.e. its offset into the file
|
||||
* stream. Implements support for ftell().
|
||||
* @return int
|
||||
*/
|
||||
public function stream_tell()
|
||||
{
|
||||
return $this->pos;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements support for fseek().
|
||||
* @param int byte offset
|
||||
* @param int SEEK_SET, SEEK_CUR or SEEK_END
|
||||
* @return bool
|
||||
*/
|
||||
public function stream_seek($offset, $whence)
|
||||
{
|
||||
if ($whence == SEEK_SET && $offset >= 0) {
|
||||
$this->pos = $offset;
|
||||
} elseif ($whence == SEEK_CUR && -$offset <= $this->pos) {
|
||||
$this->pos += $offset;
|
||||
} elseif ($whence == SEEK_END && -$offset <= sizeof($this->data)) {
|
||||
$this->pos = strlen($this->data) + $offset;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implements support for fstat(). Currently the only supported field is
|
||||
* "size".
|
||||
* @return array
|
||||
*/
|
||||
public function stream_stat()
|
||||
{
|
||||
return array(
|
||||
'size' => strlen($this->data),
|
||||
);
|
||||
}
|
||||
|
||||
// Methods used by stream_wrapper_register() that are not implemented:
|
||||
// bool stream_flush ( void )
|
||||
// int stream_write ( string data )
|
||||
// bool rename ( string path_from, string path_to )
|
||||
// bool mkdir ( string path, int mode, int options )
|
||||
// bool rmdir ( string path, int options )
|
||||
// bool dir_opendir ( string path, int options )
|
||||
// array url_stat ( string path, int flags )
|
||||
// string dir_readdir ( void )
|
||||
// bool dir_rewinddir ( void )
|
||||
// bool dir_closedir ( void )
|
||||
}
|
||||
122
include/PHPExcel/PHPExcel/Shared/OLE/OLE_File.php
Executable file
122
include/PHPExcel/PHPExcel/Shared/OLE/OLE_File.php
Executable file
@@ -0,0 +1,122 @@
|
||||
<?php
|
||||
/* vim: set expandtab tabstop=4 shiftwidth=4: */
|
||||
// +----------------------------------------------------------------------+
|
||||
// | PHP Version 4 |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Copyright (c) 1997-2002 The PHP Group |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | This source file is subject to version 2.02 of the PHP license, |
|
||||
// | that is bundled with this package in the file LICENSE, and is |
|
||||
// | available at through the world-wide-web at |
|
||||
// | http://www.php.net/license/2_02.txt. |
|
||||
// | If you did not receive a copy of the PHP license and are unable to |
|
||||
// | obtain it through the world-wide-web, please send a note to |
|
||||
// | license@php.net so we can mail you a copy immediately. |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Author: Xavier Noguer <xnoguer@php.net> |
|
||||
// | Based on OLE::Storage_Lite by Kawai, Takanori |
|
||||
// +----------------------------------------------------------------------+
|
||||
//
|
||||
// $Id: File.php,v 1.11 2007/02/13 21:00:42 schmidt Exp $
|
||||
|
||||
|
||||
require_once 'PHPExcel/Shared/OLE/OLE_PPS.php';
|
||||
|
||||
/**
|
||||
* Class for creating File PPS's for OLE containers
|
||||
*
|
||||
* @author Xavier Noguer <xnoguer@php.net>
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_OLE
|
||||
*/
|
||||
class PHPExcel_Shared_OLE_PPS_File extends PHPExcel_Shared_OLE_PPS
|
||||
{
|
||||
/**
|
||||
* The temporary dir for storing the OLE file
|
||||
* @var string
|
||||
*/
|
||||
public $_tmp_dir;
|
||||
|
||||
/**
|
||||
* The constructor
|
||||
*
|
||||
* @access public
|
||||
* @param string $name The name of the file (in Unicode)
|
||||
* @see OLE::Asc2Ucs()
|
||||
*/
|
||||
public function __construct($name)
|
||||
{
|
||||
$this->_tmp_dir = '';
|
||||
parent::__construct(
|
||||
null,
|
||||
$name,
|
||||
PHPExcel_Shared_OLE::OLE_PPS_TYPE_FILE,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
null,
|
||||
'',
|
||||
array());
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the temp dir used for storing the OLE file
|
||||
*
|
||||
* @access public
|
||||
* @param string $dir The dir to be used as temp dir
|
||||
* @return true if given dir is valid, false otherwise
|
||||
*/
|
||||
public function setTempDir($dir)
|
||||
{
|
||||
if (is_dir($dir)) {
|
||||
$this->_tmp_dir = $dir;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialization method. Has to be called right after OLE_PPS_File().
|
||||
*
|
||||
* @access public
|
||||
* @return mixed true on success
|
||||
*/
|
||||
public function init()
|
||||
{
|
||||
$this->_tmp_filename = tempnam($this->_tmp_dir, "OLE_PPS_File");
|
||||
$fh = fopen($this->_tmp_filename, "w+b");
|
||||
if ($fh === false) {
|
||||
throw new Exception("Can't create temporary file");
|
||||
}
|
||||
$this->_PPS_FILE = $fh;
|
||||
if ($this->_PPS_FILE) {
|
||||
fseek($this->_PPS_FILE, 0);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Append data to PPS
|
||||
*
|
||||
* @access public
|
||||
* @param string $data The data to append
|
||||
*/
|
||||
public function append($data)
|
||||
{
|
||||
if ($this->_PPS_FILE) {
|
||||
fwrite($this->_PPS_FILE, $data);
|
||||
} else {
|
||||
$this->_data .= $data;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a stream for reading this file using fread() etc.
|
||||
* @return resource a read-only stream
|
||||
*/
|
||||
public function getStream()
|
||||
{
|
||||
$this->ole->getStream($this);
|
||||
}
|
||||
}
|
||||
220
include/PHPExcel/PHPExcel/Shared/OLE/OLE_PPS.php
Executable file
220
include/PHPExcel/PHPExcel/Shared/OLE/OLE_PPS.php
Executable file
@@ -0,0 +1,220 @@
|
||||
<?php
|
||||
/* vim: set expandtab tabstop=4 shiftwidth=4: */
|
||||
// +----------------------------------------------------------------------+
|
||||
// | PHP Version 4 |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Copyright (c) 1997-2002 The PHP Group |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | This source file is subject to version 2.02 of the PHP license, |
|
||||
// | that is bundled with this package in the file LICENSE, and is |
|
||||
// | available at through the world-wide-web at |
|
||||
// | http://www.php.net/license/2_02.txt. |
|
||||
// | If you did not receive a copy of the PHP license and are unable to |
|
||||
// | obtain it through the world-wide-web, please send a note to |
|
||||
// | license@php.net so we can mail you a copy immediately. |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Author: Xavier Noguer <xnoguer@php.net> |
|
||||
// | Based on OLE::Storage_Lite by Kawai, Takanori |
|
||||
// +----------------------------------------------------------------------+
|
||||
//
|
||||
// $Id: PPS.php,v 1.7 2007/02/13 21:00:42 schmidt Exp $
|
||||
|
||||
|
||||
require_once 'PHPExcel/Shared/OLE.php';
|
||||
|
||||
/**
|
||||
* Class for creating PPS's for OLE containers
|
||||
*
|
||||
* @author Xavier Noguer <xnoguer@php.net>
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_OLE
|
||||
*/
|
||||
class PHPExcel_Shared_OLE_PPS
|
||||
{
|
||||
/**
|
||||
* The PPS index
|
||||
* @var integer
|
||||
*/
|
||||
public $No;
|
||||
|
||||
/**
|
||||
* The PPS name (in Unicode)
|
||||
* @var string
|
||||
*/
|
||||
public $Name;
|
||||
|
||||
/**
|
||||
* The PPS type. Dir, Root or File
|
||||
* @var integer
|
||||
*/
|
||||
public $Type;
|
||||
|
||||
/**
|
||||
* The index of the previous PPS
|
||||
* @var integer
|
||||
*/
|
||||
public $PrevPps;
|
||||
|
||||
/**
|
||||
* The index of the next PPS
|
||||
* @var integer
|
||||
*/
|
||||
public $NextPps;
|
||||
|
||||
/**
|
||||
* The index of it's first child if this is a Dir or Root PPS
|
||||
* @var integer
|
||||
*/
|
||||
public $DirPps;
|
||||
|
||||
/**
|
||||
* A timestamp
|
||||
* @var integer
|
||||
*/
|
||||
public $Time1st;
|
||||
|
||||
/**
|
||||
* A timestamp
|
||||
* @var integer
|
||||
*/
|
||||
public $Time2nd;
|
||||
|
||||
/**
|
||||
* Starting block (small or big) for this PPS's data inside the container
|
||||
* @var integer
|
||||
*/
|
||||
public $_StartBlock;
|
||||
|
||||
/**
|
||||
* The size of the PPS's data (in bytes)
|
||||
* @var integer
|
||||
*/
|
||||
public $Size;
|
||||
|
||||
/**
|
||||
* The PPS's data (only used if it's not using a temporary file)
|
||||
* @var string
|
||||
*/
|
||||
public $_data;
|
||||
|
||||
/**
|
||||
* Array of child PPS's (only used by Root and Dir PPS's)
|
||||
* @var array
|
||||
*/
|
||||
public $children = array();
|
||||
|
||||
/**
|
||||
* Pointer to OLE container
|
||||
* @var OLE
|
||||
*/
|
||||
public $ole;
|
||||
|
||||
/**
|
||||
* The constructor
|
||||
*
|
||||
* @access public
|
||||
* @param integer $No The PPS index
|
||||
* @param string $name The PPS name
|
||||
* @param integer $type The PPS type. Dir, Root or File
|
||||
* @param integer $prev The index of the previous PPS
|
||||
* @param integer $next The index of the next PPS
|
||||
* @param integer $dir The index of it's first child if this is a Dir or Root PPS
|
||||
* @param integer $time_1st A timestamp
|
||||
* @param integer $time_2nd A timestamp
|
||||
* @param string $data The (usually binary) source data of the PPS
|
||||
* @param array $children Array containing children PPS for this PPS
|
||||
*/
|
||||
public function __construct($No, $name, $type, $prev, $next, $dir, $time_1st, $time_2nd, $data, $children)
|
||||
{
|
||||
$this->No = $No;
|
||||
$this->Name = $name;
|
||||
$this->Type = $type;
|
||||
$this->PrevPps = $prev;
|
||||
$this->NextPps = $next;
|
||||
$this->DirPps = $dir;
|
||||
$this->Time1st = $time_1st;
|
||||
$this->Time2nd = $time_2nd;
|
||||
$this->_data = $data;
|
||||
$this->children = $children;
|
||||
if ($data != '') {
|
||||
$this->Size = strlen($data);
|
||||
} else {
|
||||
$this->Size = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the amount of data saved for this PPS
|
||||
*
|
||||
* @access public
|
||||
* @return integer The amount of data (in bytes)
|
||||
*/
|
||||
public function _DataLen()
|
||||
{
|
||||
if (!isset($this->_data)) {
|
||||
return 0;
|
||||
}
|
||||
if (isset($this->_PPS_FILE)) {
|
||||
fseek($this->_PPS_FILE, 0);
|
||||
$stats = fstat($this->_PPS_FILE);
|
||||
return $stats[7];
|
||||
} else {
|
||||
return strlen($this->_data);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a string with the PPS's WK (What is a WK?)
|
||||
*
|
||||
* @access public
|
||||
* @return string The binary string
|
||||
*/
|
||||
public function _getPpsWk()
|
||||
{
|
||||
$ret = $this->Name;
|
||||
for ($i = 0; $i < (64 - strlen($this->Name)); ++$i) {
|
||||
$ret .= "\x00";
|
||||
}
|
||||
$ret .= pack("v", strlen($this->Name) + 2) // 66
|
||||
. pack("c", $this->Type) // 67
|
||||
. pack("c", 0x00) //UK // 68
|
||||
. pack("V", $this->PrevPps) //Prev // 72
|
||||
. pack("V", $this->NextPps) //Next // 76
|
||||
. pack("V", $this->DirPps) //Dir // 80
|
||||
. "\x00\x09\x02\x00" // 84
|
||||
. "\x00\x00\x00\x00" // 88
|
||||
. "\xc0\x00\x00\x00" // 92
|
||||
. "\x00\x00\x00\x46" // 96 // Seems to be ok only for Root
|
||||
. "\x00\x00\x00\x00" // 100
|
||||
. PHPExcel_Shared_OLE::LocalDate2OLE($this->Time1st) // 108
|
||||
. PHPExcel_Shared_OLE::LocalDate2OLE($this->Time2nd) // 116
|
||||
. pack("V", isset($this->_StartBlock)?
|
||||
$this->_StartBlock:0) // 120
|
||||
. pack("V", $this->Size) // 124
|
||||
. pack("V", 0); // 128
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates index and pointers to previous, next and children PPS's for this
|
||||
* PPS. I don't think it'll work with Dir PPS's.
|
||||
*
|
||||
* @access public
|
||||
* @param array &$pps_array Reference to the array of PPS's for the whole OLE
|
||||
* container
|
||||
* @return integer The index for this PPS
|
||||
*/
|
||||
public function _savePpsSetPnt(&$pps_array)
|
||||
{
|
||||
$pps_array[count($pps_array)] = &$this;
|
||||
$this->No = count($pps_array) - 1;
|
||||
$this->PrevPps = 0xFFFFFFFF;
|
||||
$this->NextPps = 0xFFFFFFFF;
|
||||
if (count($this->children) > 0) {
|
||||
$this->DirPps = $this->children[0]->_savePpsSetPnt($pps_array);
|
||||
} else {
|
||||
$this->DirPps = 0xFFFFFFFF;
|
||||
}
|
||||
return $this->No;
|
||||
}
|
||||
}
|
||||
481
include/PHPExcel/PHPExcel/Shared/OLE/OLE_Root.php
Executable file
481
include/PHPExcel/PHPExcel/Shared/OLE/OLE_Root.php
Executable file
@@ -0,0 +1,481 @@
|
||||
<?php
|
||||
/* vim: set expandtab tabstop=4 shiftwidth=4: */
|
||||
// +----------------------------------------------------------------------+
|
||||
// | PHP Version 4 |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Copyright (c) 1997-2002 The PHP Group |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | This source file is subject to version 2.02 of the PHP license, |
|
||||
// | that is bundled with this package in the file LICENSE, and is |
|
||||
// | available at through the world-wide-web at |
|
||||
// | http://www.php.net/license/2_02.txt. |
|
||||
// | If you did not receive a copy of the PHP license and are unable to |
|
||||
// | obtain it through the world-wide-web, please send a note to |
|
||||
// | license@php.net so we can mail you a copy immediately. |
|
||||
// +----------------------------------------------------------------------+
|
||||
// | Author: Xavier Noguer <xnoguer@php.net> |
|
||||
// | Based on OLE::Storage_Lite by Kawai, Takanori |
|
||||
// +----------------------------------------------------------------------+
|
||||
//
|
||||
// $Id: Root.php,v 1.9 2005/04/23 21:53:49 dufuz Exp $
|
||||
|
||||
|
||||
require_once 'PHPExcel/Shared/OLE/OLE_PPS.php';
|
||||
|
||||
/**
|
||||
* Class for creating Root PPS's for OLE containers
|
||||
*
|
||||
* @author Xavier Noguer <xnoguer@php.net>
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared_OLE
|
||||
*/
|
||||
class PHPExcel_Shared_OLE_PPS_Root extends PHPExcel_Shared_OLE_PPS
|
||||
{
|
||||
/**
|
||||
* The temporary dir for storing the OLE file
|
||||
* @var string
|
||||
*/
|
||||
public $_tmp_dir;
|
||||
|
||||
/**
|
||||
* @param integer $time_1st A timestamp
|
||||
* @param integer $time_2nd A timestamp
|
||||
*/
|
||||
public function __construct($time_1st, $time_2nd, $raChild)
|
||||
{
|
||||
$this->_tmp_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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the temp dir used for storing the OLE file
|
||||
*
|
||||
* @access public
|
||||
* @param string $dir The dir to be used as temp dir
|
||||
* @return true if given dir is valid, false otherwise
|
||||
*/
|
||||
public function setTempDir($dir)
|
||||
{
|
||||
if (is_dir($dir)) {
|
||||
$this->_tmp_dir = $dir;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @param string $filename The name of the file 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))? $this->_adjust2($this->_BIG_BLOCK_SIZE) : 9));
|
||||
$this->_SMALL_BLOCK_SIZE= pow(2,
|
||||
((isset($this->_SMALL_BLOCK_SIZE))? $this->_adjust2($this->_SMALL_BLOCK_SIZE): 6));
|
||||
|
||||
// Open temp file if we are sending output to stdout
|
||||
if ($filename == '-' || $filename == '') {
|
||||
$this->_tmp_filename = tempnam($this->_tmp_dir, "OLE_PPS_Root");
|
||||
$this->_FILEH_ = fopen($this->_tmp_filename,"w+b");
|
||||
if ($this->_FILEH_ == false) {
|
||||
throw new Exception("Can't create temporary file.");
|
||||
}
|
||||
} else {
|
||||
$this->_FILEH_ = fopen($filename, "wb");
|
||||
if ($this->_FILEH_ == false) {
|
||||
throw new Exception("Can't open $filename. It may be in use or protected.");
|
||||
}
|
||||
}
|
||||
// Make an array of PPS's (for Save)
|
||||
$aList = array();
|
||||
$this->_savePpsSetPnt($aList);
|
||||
// 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);
|
||||
// Close File, send it to stdout if necessary
|
||||
if (($filename == '-') || ($filename == '')) {
|
||||
fseek($this->_FILEH_, 0);
|
||||
fpassthru($this->_FILEH_);
|
||||
fclose($this->_FILEH_);
|
||||
// Delete the temporary file.
|
||||
unlink($this->_tmp_filename);
|
||||
} else {
|
||||
fclose($this->_FILEH_);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate some numbers
|
||||
*
|
||||
* @access public
|
||||
* @param array $raList Reference to an array of PPS's
|
||||
* @return array The array of numbers
|
||||
*/
|
||||
public function _calcSize(&$raList)
|
||||
{
|
||||
// Calculate Basic Setting
|
||||
list($iSBDcnt, $iBBcnt, $iPPScnt) = array(0,0,0);
|
||||
$iSmallLen = 0;
|
||||
$iSBcnt = 0;
|
||||
for ($i = 0; $i < count($raList); ++$i) {
|
||||
if ($raList[$i]->Type == PHPExcel_Shared_OLE::OLE_PPS_TYPE_FILE) {
|
||||
$raList[$i]->Size = $raList[$i]->_DataLen();
|
||||
if ($raList[$i]->Size < PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) {
|
||||
$iSBcnt += floor($raList[$i]->Size / $this->_SMALL_BLOCK_SIZE)
|
||||
+ (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)? 1: 0);
|
||||
} else {
|
||||
$iBBcnt += (floor($raList[$i]->Size / $this->_BIG_BLOCK_SIZE) +
|
||||
(($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)? 1: 0));
|
||||
}
|
||||
}
|
||||
}
|
||||
$iSmallLen = $iSBcnt * $this->_SMALL_BLOCK_SIZE;
|
||||
$iSlCnt = floor($this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE);
|
||||
$iSBDcnt = floor($iSBcnt / $iSlCnt) + (($iSBcnt % $iSlCnt)? 1:0);
|
||||
$iBBcnt += (floor($iSmallLen / $this->_BIG_BLOCK_SIZE) +
|
||||
(( $iSmallLen % $this->_BIG_BLOCK_SIZE)? 1: 0));
|
||||
$iCnt = count($raList);
|
||||
$iBdCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_PPS_SIZE;
|
||||
$iPPScnt = (floor($iCnt/$iBdCnt) + (($iCnt % $iBdCnt)? 1: 0));
|
||||
|
||||
return array($iSBDcnt, $iBBcnt, $iPPScnt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function for caculating a magic value for block sizes
|
||||
*
|
||||
* @access public
|
||||
* @param integer $i2 The argument
|
||||
* @see save()
|
||||
* @return integer
|
||||
*/
|
||||
public function _adjust2($i2)
|
||||
{
|
||||
$iWk = log($i2)/log(2);
|
||||
return ($iWk > floor($iWk))? floor($iWk)+1:$iWk;
|
||||
}
|
||||
|
||||
/**
|
||||
* Save OLE header
|
||||
*
|
||||
* @access public
|
||||
* @param integer $iSBDcnt
|
||||
* @param integer $iBBcnt
|
||||
* @param integer $iPPScnt
|
||||
*/
|
||||
public function _saveHeader($iSBDcnt, $iBBcnt, $iPPScnt)
|
||||
{
|
||||
$FILE = $this->_FILEH_;
|
||||
|
||||
// Calculate Basic Setting
|
||||
$iBlCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
|
||||
$i1stBdL = ($this->_BIG_BLOCK_SIZE - 0x4C) / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
|
||||
|
||||
$iBdExL = 0;
|
||||
$iAll = $iBBcnt + $iPPScnt + $iSBDcnt;
|
||||
$iAllW = $iAll;
|
||||
$iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt)? 1: 0);
|
||||
$iBdCnt = floor(($iAll + $iBdCntW) / $iBlCnt) + ((($iAllW+$iBdCntW) % $iBlCnt)? 1: 0);
|
||||
|
||||
// Calculate BD count
|
||||
if ($iBdCnt > $i1stBdL) {
|
||||
while (1) {
|
||||
++$iBdExL;
|
||||
++$iAllW;
|
||||
$iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt)? 1: 0);
|
||||
$iBdCnt = floor(($iAllW + $iBdCntW) / $iBlCnt) + ((($iAllW+$iBdCntW) % $iBlCnt)? 1: 0);
|
||||
if ($iBdCnt <= ($iBdExL*$iBlCnt+ $i1stBdL)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Save Header
|
||||
fwrite($FILE,
|
||||
"\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1"
|
||||
. "\x00\x00\x00\x00"
|
||||
. "\x00\x00\x00\x00"
|
||||
. "\x00\x00\x00\x00"
|
||||
. "\x00\x00\x00\x00"
|
||||
. pack("v", 0x3b)
|
||||
. pack("v", 0x03)
|
||||
. pack("v", -2)
|
||||
. pack("v", 9)
|
||||
. pack("v", 6)
|
||||
. pack("v", 0)
|
||||
. "\x00\x00\x00\x00"
|
||||
. "\x00\x00\x00\x00"
|
||||
. pack("V", $iBdCnt)
|
||||
. pack("V", $iBBcnt+$iSBDcnt) //ROOT START
|
||||
. pack("V", 0)
|
||||
. pack("V", 0x1000)
|
||||
. pack("V", $iSBDcnt ? 0 : -2) //Small Block Depot
|
||||
. pack("V", 1)
|
||||
);
|
||||
// Extra BDList Start, Count
|
||||
if ($iBdCnt < $i1stBdL) {
|
||||
fwrite($FILE,
|
||||
pack("V", -2). // Extra BDList Start
|
||||
pack("V", 0) // Extra BDList Count
|
||||
);
|
||||
} else {
|
||||
fwrite($FILE, pack("V", $iAll+$iBdCnt) . pack("V", $iBdExL));
|
||||
}
|
||||
|
||||
// BDList
|
||||
for ($i = 0; $i < $i1stBdL && $i < $iBdCnt; ++$i) {
|
||||
fwrite($FILE, pack("V", $iAll+$i));
|
||||
}
|
||||
if ($i < $i1stBdL) {
|
||||
for ($j = 0; $j < ($i1stBdL-$i); ++$j) {
|
||||
fwrite($FILE, (pack("V", -1)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Saving big data (PPS's with data bigger than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
|
||||
*
|
||||
* @access public
|
||||
* @param integer $iStBlk
|
||||
* @param array &$raList Reference to array of PPS's
|
||||
*/
|
||||
public function _saveBigData($iStBlk, &$raList)
|
||||
{
|
||||
$FILE = $this->_FILEH_;
|
||||
|
||||
// cycle through PPS's
|
||||
for ($i = 0; $i < count($raList); ++$i) {
|
||||
if ($raList[$i]->Type != PHPExcel_Shared_OLE::OLE_PPS_TYPE_DIR) {
|
||||
$raList[$i]->Size = $raList[$i]->_DataLen();
|
||||
if (($raList[$i]->Size >= PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) ||
|
||||
(($raList[$i]->Type == PHPExcel_Shared_OLE::OLE_PPS_TYPE_ROOT) && isset($raList[$i]->_data)))
|
||||
{
|
||||
// Write Data
|
||||
if (isset($raList[$i]->_PPS_FILE)) {
|
||||
$iLen = 0;
|
||||
fseek($raList[$i]->_PPS_FILE, 0); // To The Top
|
||||
while($sBuff = fread($raList[$i]->_PPS_FILE, 4096)) {
|
||||
$iLen += strlen($sBuff);
|
||||
fwrite($FILE, $sBuff);
|
||||
}
|
||||
} else {
|
||||
fwrite($FILE, $raList[$i]->_data);
|
||||
}
|
||||
|
||||
if ($raList[$i]->Size % $this->_BIG_BLOCK_SIZE) {
|
||||
for ($j = 0; $j < ($this->_BIG_BLOCK_SIZE - ($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)); ++$j) {
|
||||
fwrite($FILE, "\x00");
|
||||
}
|
||||
}
|
||||
// Set For PPS
|
||||
$raList[$i]->_StartBlock = $iStBlk;
|
||||
$iStBlk +=
|
||||
(floor($raList[$i]->Size / $this->_BIG_BLOCK_SIZE) +
|
||||
(($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)? 1: 0));
|
||||
}
|
||||
// Close file for each PPS, and unlink it
|
||||
if (isset($raList[$i]->_PPS_FILE)) {
|
||||
fclose($raList[$i]->_PPS_FILE);
|
||||
$raList[$i]->_PPS_FILE = null;
|
||||
unlink($raList[$i]->_tmp_filename);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* get small data (PPS's with data smaller than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
|
||||
*
|
||||
* @access public
|
||||
* @param array &$raList Reference to array of PPS's
|
||||
*/
|
||||
public function _makeSmallData(&$raList)
|
||||
{
|
||||
$sRes = '';
|
||||
$FILE = $this->_FILEH_;
|
||||
$iSmBlk = 0;
|
||||
|
||||
for ($i = 0; $i < count($raList); ++$i) {
|
||||
// Make SBD, small data string
|
||||
if ($raList[$i]->Type == PHPExcel_Shared_OLE::OLE_PPS_TYPE_FILE) {
|
||||
if ($raList[$i]->Size <= 0) {
|
||||
continue;
|
||||
}
|
||||
if ($raList[$i]->Size < PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) {
|
||||
$iSmbCnt = floor($raList[$i]->Size / $this->_SMALL_BLOCK_SIZE)
|
||||
+ (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)? 1: 0);
|
||||
// Add to SBD
|
||||
for ($j = 0; $j < ($iSmbCnt-1); ++$j) {
|
||||
fwrite($FILE, pack("V", $j+$iSmBlk+1));
|
||||
}
|
||||
fwrite($FILE, pack("V", -2));
|
||||
|
||||
// Add to Data String(this will be written for RootEntry)
|
||||
if ($raList[$i]->_PPS_FILE) {
|
||||
fseek($raList[$i]->_PPS_FILE, 0); // To The Top
|
||||
while ($sBuff = fread($raList[$i]->_PPS_FILE, 4096)) {
|
||||
$sRes .= $sBuff;
|
||||
}
|
||||
} else {
|
||||
$sRes .= $raList[$i]->_data;
|
||||
}
|
||||
if ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE) {
|
||||
for ($j = 0; $j < ($this->_SMALL_BLOCK_SIZE - ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)); ++$j) {
|
||||
$sRes .= "\x00";
|
||||
}
|
||||
}
|
||||
// Set for PPS
|
||||
$raList[$i]->_StartBlock = $iSmBlk;
|
||||
$iSmBlk += $iSmbCnt;
|
||||
}
|
||||
}
|
||||
}
|
||||
$iSbCnt = floor($this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE);
|
||||
if ($iSmBlk % $iSbCnt) {
|
||||
for ($i = 0; $i < ($iSbCnt - ($iSmBlk % $iSbCnt)); ++$i) {
|
||||
fwrite($FILE, pack("V", -1));
|
||||
}
|
||||
}
|
||||
return $sRes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves all the PPS's WKs
|
||||
*
|
||||
* @access public
|
||||
* @param array $raList Reference to an array with all PPS's
|
||||
*/
|
||||
public function _savePps(&$raList)
|
||||
{
|
||||
// Save each PPS WK
|
||||
for ($i = 0; $i < count($raList); ++$i) {
|
||||
fwrite($this->_FILEH_, $raList[$i]->_getPpsWk());
|
||||
}
|
||||
// Adjust for Block
|
||||
$iCnt = count($raList);
|
||||
$iBCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_PPS_SIZE;
|
||||
if ($iCnt % $iBCnt) {
|
||||
for ($i = 0; $i < (($iBCnt - ($iCnt % $iBCnt)) * PHPExcel_Shared_OLE::OLE_PPS_SIZE); ++$i) {
|
||||
fwrite($this->_FILEH_, "\x00");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Saving Big Block Depot
|
||||
*
|
||||
* @access public
|
||||
* @param integer $iSbdSize
|
||||
* @param integer $iBsize
|
||||
* @param integer $iPpsCnt
|
||||
*/
|
||||
public function _saveBbd($iSbdSize, $iBsize, $iPpsCnt)
|
||||
{
|
||||
$FILE = $this->_FILEH_;
|
||||
// Calculate Basic Setting
|
||||
$iBbCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
|
||||
$i1stBdL = ($this->_BIG_BLOCK_SIZE - 0x4C) / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE;
|
||||
|
||||
$iBdExL = 0;
|
||||
$iAll = $iBsize + $iPpsCnt + $iSbdSize;
|
||||
$iAllW = $iAll;
|
||||
$iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt)? 1: 0);
|
||||
$iBdCnt = floor(($iAll + $iBdCntW) / $iBbCnt) + ((($iAllW+$iBdCntW) % $iBbCnt)? 1: 0);
|
||||
// Calculate BD count
|
||||
if ($iBdCnt >$i1stBdL) {
|
||||
while (1) {
|
||||
++$iBdExL;
|
||||
++$iAllW;
|
||||
$iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt)? 1: 0);
|
||||
$iBdCnt = floor(($iAllW + $iBdCntW) / $iBbCnt) + ((($iAllW+$iBdCntW) % $iBbCnt)? 1: 0);
|
||||
if ($iBdCnt <= ($iBdExL*$iBbCnt+ $i1stBdL)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Making BD
|
||||
// Set for SBD
|
||||
if ($iSbdSize > 0) {
|
||||
for ($i = 0; $i < ($iSbdSize - 1); ++$i) {
|
||||
fwrite($FILE, pack("V", $i+1));
|
||||
}
|
||||
fwrite($FILE, pack("V", -2));
|
||||
}
|
||||
// Set for B
|
||||
for ($i = 0; $i < ($iBsize - 1); ++$i) {
|
||||
fwrite($FILE, pack("V", $i+$iSbdSize+1));
|
||||
}
|
||||
fwrite($FILE, pack("V", -2));
|
||||
|
||||
// Set for PPS
|
||||
for ($i = 0; $i < ($iPpsCnt - 1); ++$i) {
|
||||
fwrite($FILE, pack("V", $i+$iSbdSize+$iBsize+1));
|
||||
}
|
||||
fwrite($FILE, pack("V", -2));
|
||||
// Set for BBD itself ( 0xFFFFFFFD : BBD)
|
||||
for ($i = 0; $i < $iBdCnt; ++$i) {
|
||||
fwrite($FILE, pack("V", 0xFFFFFFFD));
|
||||
}
|
||||
// Set for ExtraBDList
|
||||
for ($i = 0; $i < $iBdExL; ++$i) {
|
||||
fwrite($FILE, pack("V", 0xFFFFFFFC));
|
||||
}
|
||||
// Adjust for Block
|
||||
if (($iAllW + $iBdCnt) % $iBbCnt) {
|
||||
for ($i = 0; $i < ($iBbCnt - (($iAllW + $iBdCnt) % $iBbCnt)); ++$i) {
|
||||
fwrite($FILE, pack("V", -1));
|
||||
}
|
||||
}
|
||||
// Extra BDList
|
||||
if ($iBdCnt > $i1stBdL) {
|
||||
$iN=0;
|
||||
$iNb=0;
|
||||
for ($i = $i1stBdL;$i < $iBdCnt; $i++, ++$iN) {
|
||||
if ($iN >= ($iBbCnt - 1)) {
|
||||
$iN = 0;
|
||||
++$iNb;
|
||||
fwrite($FILE, pack("V", $iAll+$iBdCnt+$iNb));
|
||||
}
|
||||
fwrite($FILE, pack("V", $iBsize+$iSbdSize+$iPpsCnt+$i));
|
||||
}
|
||||
if (($iBdCnt-$i1stBdL) % ($iBbCnt-1)) {
|
||||
for ($i = 0; $i < (($iBbCnt - 1) - (($iBdCnt - $i1stBdL) % ($iBbCnt - 1))); ++$i) {
|
||||
fwrite($FILE, pack("V", -1));
|
||||
}
|
||||
}
|
||||
fwrite($FILE, pack("V", -2));
|
||||
}
|
||||
}
|
||||
}
|
||||
276
include/PHPExcel/PHPExcel/Shared/OLERead.php
Executable file
276
include/PHPExcel/PHPExcel/Shared/OLERead.php
Executable file
@@ -0,0 +1,276 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
define('IDENTIFIER_OLE', pack("CCCCCCCC", 0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1));
|
||||
define('IDENTIFIER_BIFF7', pack("CCCCCCCC", 0x09,0x08,0x08,0x00,0x00,0x05,0x05,0x00));
|
||||
define('IDENTIFIER_BIFF8', pack("CCCCCCCC", 0x09,0x08,0x10,0x00,0x00,0x06,0x05,0x00));
|
||||
// OpenOffice and Excel 97-2004 for Mac.
|
||||
define('IDENTIFIER_OOF', pack("CCCCCCCC", 0xfd,0xff,0xff,0xff,0xff,0xff,0xff,0xff));
|
||||
define('IDENTIFIER_MAC04', pack("CCCCCCCC", 0xfd,0xff,0xff,0xff,0x23,0x00,0x00,0x00));
|
||||
|
||||
|
||||
class PHPExcel_Shared_OLERead {
|
||||
public $data = '';
|
||||
|
||||
const NUM_BIG_BLOCK_DEPOT_BLOCKS_POS = 0x2c;
|
||||
const SMALL_BLOCK_DEPOT_BLOCK_POS = 0x3c;
|
||||
const ROOT_START_BLOCK_POS = 0x30;
|
||||
const BIG_BLOCK_SIZE = 0x200;
|
||||
const SMALL_BLOCK_SIZE = 0x40;
|
||||
const EXTENSION_BLOCK_POS = 0x44;
|
||||
const NUM_EXTENSION_BLOCK_POS = 0x48;
|
||||
const PROPERTY_STORAGE_BLOCK_SIZE = 0x80;
|
||||
const BIG_BLOCK_DEPOT_BLOCKS_POS = 0x4c;
|
||||
const SMALL_BLOCK_THRESHOLD = 0x1000;
|
||||
// property storage offsets
|
||||
const SIZE_OF_NAME_POS = 0x40;
|
||||
const TYPE_POS = 0x42;
|
||||
const START_BLOCK_POS = 0x74;
|
||||
const SIZE_POS = 0x78;
|
||||
const IDENTIFIER_OLE = IDENTIFIER_OLE;
|
||||
const IDENTIFIER_BIFF7 = IDENTIFIER_BIFF7;
|
||||
const IDENTIFIER_BIFF8 = IDENTIFIER_BIFF8;
|
||||
// OpenOffice and Excel 97-2004 for Mac.
|
||||
const IDENTIFIER_OOF = IDENTIFIER_OOF;
|
||||
const IDENTIFIER_MAC04 = IDENTIFIER_MAC04;
|
||||
|
||||
public function read($sFileName)
|
||||
{
|
||||
// check if file exist and is readable (Darko Miljanovic)
|
||||
if(!is_readable($sFileName)) {
|
||||
$this->error = 1;
|
||||
return false;
|
||||
}
|
||||
|
||||
$this->data = file_get_contents($sFileName);
|
||||
if (!$this->data) {
|
||||
$this->error = 1;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (substr($this->data, 0, 8) != self::IDENTIFIER_OLE) {
|
||||
$this->error = 1;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check the start of the first block for a signature found in valid
|
||||
// Excel files
|
||||
|
||||
// Incorrectly throws out some valid Excel files. Removing for now.
|
||||
/*$identifiers = array(
|
||||
IDENTIFIER_BIFF7,
|
||||
IDENTIFIER_BIFF8,
|
||||
IDENTIFIER_OOF,
|
||||
IDENTIFIER_MAC04
|
||||
);
|
||||
|
||||
if (!in_array(substr($this->data, 512, 8), $identifiers)) {
|
||||
$this->error = 2;
|
||||
return false;
|
||||
}*/
|
||||
|
||||
$this->numBigBlockDepotBlocks = $this->_GetInt4d($this->data, self::NUM_BIG_BLOCK_DEPOT_BLOCKS_POS);
|
||||
$this->sbdStartBlock = $this->_GetInt4d($this->data, self::SMALL_BLOCK_DEPOT_BLOCK_POS);
|
||||
$this->rootStartBlock = $this->_GetInt4d($this->data, self::ROOT_START_BLOCK_POS);
|
||||
$this->extensionBlock = $this->_GetInt4d($this->data, self::EXTENSION_BLOCK_POS);
|
||||
$this->numExtensionBlocks = $this->_GetInt4d($this->data, self::NUM_EXTENSION_BLOCK_POS);
|
||||
|
||||
$bigBlockDepotBlocks = array();
|
||||
$pos = self::BIG_BLOCK_DEPOT_BLOCKS_POS;
|
||||
|
||||
$bbdBlocks = $this->numBigBlockDepotBlocks;
|
||||
|
||||
if ($this->numExtensionBlocks != 0) {
|
||||
$bbdBlocks = (self::BIG_BLOCK_SIZE - self::BIG_BLOCK_DEPOT_BLOCKS_POS)/4;
|
||||
}
|
||||
|
||||
for ($i = 0; $i < $bbdBlocks; ++$i) {
|
||||
$bigBlockDepotBlocks[$i] = $this->_GetInt4d($this->data, $pos);
|
||||
$pos += 4;
|
||||
}
|
||||
|
||||
for ($j = 0; $j < $this->numExtensionBlocks; ++$j) {
|
||||
$pos = ($this->extensionBlock + 1) * self::BIG_BLOCK_SIZE;
|
||||
$blocksToRead = min($this->numBigBlockDepotBlocks - $bbdBlocks, self::BIG_BLOCK_SIZE / 4 - 1);
|
||||
|
||||
for ($i = $bbdBlocks; $i < $bbdBlocks + $blocksToRead; ++$i) {
|
||||
$bigBlockDepotBlocks[$i] = $this->_GetInt4d($this->data, $pos);
|
||||
$pos += 4;
|
||||
}
|
||||
|
||||
$bbdBlocks += $blocksToRead;
|
||||
if ($bbdBlocks < $this->numBigBlockDepotBlocks) {
|
||||
$this->extensionBlock = $this->_GetInt4d($this->data, $pos);
|
||||
}
|
||||
}
|
||||
|
||||
$pos = 0;
|
||||
$index = 0;
|
||||
$this->bigBlockChain = array();
|
||||
|
||||
for ($i = 0; $i < $this->numBigBlockDepotBlocks; ++$i) {
|
||||
$pos = ($bigBlockDepotBlocks[$i] + 1) * self::BIG_BLOCK_SIZE;
|
||||
|
||||
for ($j = 0 ; $j < self::BIG_BLOCK_SIZE / 4; ++$j) {
|
||||
$this->bigBlockChain[$index] = $this->_GetInt4d($this->data, $pos);
|
||||
$pos += 4 ;
|
||||
++$index;
|
||||
}
|
||||
}
|
||||
|
||||
$pos = 0;
|
||||
$index = 0;
|
||||
$sbdBlock = $this->sbdStartBlock;
|
||||
$this->smallBlockChain = array();
|
||||
|
||||
while ($sbdBlock != -2) {
|
||||
$pos = ($sbdBlock + 1) * self::BIG_BLOCK_SIZE;
|
||||
|
||||
for ($j = 0; $j < self::BIG_BLOCK_SIZE / 4; ++$j) {
|
||||
$this->smallBlockChain[$index] = $this->_GetInt4d($this->data, $pos);
|
||||
$pos += 4;
|
||||
++$index;
|
||||
}
|
||||
|
||||
$sbdBlock = $this->bigBlockChain[$sbdBlock];
|
||||
}
|
||||
|
||||
$block = $this->rootStartBlock;
|
||||
$pos = 0;
|
||||
$this->entry = $this->_readData($block);
|
||||
|
||||
$this->_readPropertySets();
|
||||
|
||||
}
|
||||
|
||||
public function getWorkBook()
|
||||
{
|
||||
if ($this->props[$this->wrkbook]['size'] < self::SMALL_BLOCK_THRESHOLD){
|
||||
$rootdata = $this->_readData($this->props[$this->rootentry]['startBlock']);
|
||||
|
||||
$streamData = '';
|
||||
$block = $this->props[$this->wrkbook]['startBlock'];
|
||||
|
||||
$pos = 0;
|
||||
while ($block != -2) {
|
||||
$pos = $block * self::SMALL_BLOCK_SIZE;
|
||||
$streamData .= substr($rootdata, $pos, self::SMALL_BLOCK_SIZE);
|
||||
|
||||
$block = $this->smallBlockChain[$block];
|
||||
}
|
||||
|
||||
return $streamData;
|
||||
|
||||
|
||||
} else {
|
||||
$numBlocks = $this->props[$this->wrkbook]['size'] / self::BIG_BLOCK_SIZE;
|
||||
if ($this->props[$this->wrkbook]['size'] % self::BIG_BLOCK_SIZE != 0) {
|
||||
++$numBlocks;
|
||||
}
|
||||
|
||||
if ($numBlocks == 0) return '';
|
||||
|
||||
|
||||
$streamData = '';
|
||||
$block = $this->props[$this->wrkbook]['startBlock'];
|
||||
|
||||
$pos = 0;
|
||||
|
||||
while ($block != -2) {
|
||||
$pos = ($block + 1) * self::BIG_BLOCK_SIZE;
|
||||
$streamData .= substr($this->data, $pos, self::BIG_BLOCK_SIZE);
|
||||
$block = $this->bigBlockChain[$block];
|
||||
}
|
||||
|
||||
return $streamData;
|
||||
}
|
||||
}
|
||||
|
||||
public function _GetInt4d($data, $pos)
|
||||
{
|
||||
// Hacked by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems
|
||||
$_or_24 = ord($data[$pos+3]);
|
||||
if ($_or_24>=128) $_ord_24 = -abs((256-$_or_24) << 24);
|
||||
else $_ord_24 = ($_or_24&127) << 24;
|
||||
|
||||
return ord($data[$pos]) | (ord($data[$pos+1]) << 8) | (ord($data[$pos+2]) << 16) | $_ord_24;
|
||||
}
|
||||
|
||||
public function _readData($bl)
|
||||
{
|
||||
$block = $bl;
|
||||
$pos = 0;
|
||||
$data = '';
|
||||
|
||||
while ($block != -2) {
|
||||
$pos = ($block + 1) * self::BIG_BLOCK_SIZE;
|
||||
$data = $data.substr($this->data, $pos, self::BIG_BLOCK_SIZE);
|
||||
$block = $this->bigBlockChain[$block];
|
||||
}
|
||||
return $data;
|
||||
}
|
||||
|
||||
public function _readPropertySets()
|
||||
{
|
||||
$offset = 0;
|
||||
|
||||
while ($offset < strlen($this->entry)) {
|
||||
$d = substr($this->entry, $offset, self::PROPERTY_STORAGE_BLOCK_SIZE);
|
||||
|
||||
$nameSize = ord($d[self::SIZE_OF_NAME_POS]) | (ord($d[self::SIZE_OF_NAME_POS+1]) << 8);
|
||||
|
||||
$type = ord($d[self::TYPE_POS]);
|
||||
|
||||
$startBlock = $this->_GetInt4d($d, self::START_BLOCK_POS);
|
||||
$size = $this->_GetInt4d($d, self::SIZE_POS);
|
||||
|
||||
$name = '';
|
||||
for ($i = 0; $i < $nameSize ; ++$i) {
|
||||
$name .= $d[$i];
|
||||
}
|
||||
|
||||
$name = str_replace("\x00", "", $name);
|
||||
|
||||
$this->props[] = array (
|
||||
'name' => $name,
|
||||
'type' => $type,
|
||||
'startBlock' => $startBlock,
|
||||
'size' => $size);
|
||||
|
||||
if (($name == "Workbook") || ($name == "Book") || ($name == "WORKBOOK")) {
|
||||
$this->wrkbook = count($this->props) - 1;
|
||||
}
|
||||
|
||||
if ($name == "Root Entry" || $name == "ROOT ENTRY") {
|
||||
$this->rootentry = count($this->props) - 1;
|
||||
}
|
||||
|
||||
$offset += self::PROPERTY_STORAGE_BLOCK_SIZE;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
31
include/PHPExcel/PHPExcel/Shared/PDF.php
Executable file
31
include/PHPExcel/PHPExcel/Shared/PDF.php
Executable file
@@ -0,0 +1,31 @@
|
||||
<?php
|
||||
/**
|
||||
* PHPExcel
|
||||
*
|
||||
* Copyright (c) 2006 - 2009 PHPExcel
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* @category PHPExcel
|
||||
* @package PHPExcel_Shared
|
||||
* @copyright Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
|
||||
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
||||
* @version 1.6.6, 2009-03-02
|
||||
*/
|
||||
|
||||
|
||||
/** Require FPDF library */
|
||||
$k_path_url = dirname(__FILE__) . '/PDF';
|
||||
require_once 'PHPExcel/Shared/PDF/tcpdf.php';
|
||||
810
include/PHPExcel/PHPExcel/Shared/PDF/barcodes.php
Executable file
810
include/PHPExcel/PHPExcel/Shared/PDF/barcodes.php
Executable file
@@ -0,0 +1,810 @@
|
||||
<?php
|
||||
//============================================================+
|
||||
// File name : barcodes.php
|
||||
// Begin : 2008-06-09
|
||||
// Last Update : 2009-02-13
|
||||
// Version : 1.0.005
|
||||
// License : GNU LGPL (http://www.gnu.org/copyleft/lesser.html)
|
||||
// ----------------------------------------------------------------------------
|
||||
// Copyright (C) 2008-2009 Nicola Asuni - Tecnick.com S.r.l.
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 2.1 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//
|
||||
// See LICENSE.TXT file for more information.
|
||||
// ----------------------------------------------------------------------------
|
||||
//
|
||||
// Description : PHP class to creates array representations for
|
||||
// common 1D barcodes to be used with TCPDF.
|
||||
//
|
||||
// Author: Nicola Asuni
|
||||
//
|
||||
// (c) Copyright:
|
||||
// Nicola Asuni
|
||||
// Tecnick.com S.r.l.
|
||||
// Via della Pace, 11
|
||||
// 09044 Quartucciu (CA)
|
||||
// ITALY
|
||||
// www.tecnick.com
|
||||
// info@tecnick.com
|
||||
//============================================================+
|
||||
|
||||
/**
|
||||
* PHP class to creates array representations for common 1D barcodes to be used with TCPDF.
|
||||
* @package com.tecnick.tcpdf
|
||||
* @abstract Functions for generating string representation of common 1D barcodes.
|
||||
* @author Nicola Asuni
|
||||
* @copyright 2008-2009 Nicola Asuni - Tecnick.com S.r.l (www.tecnick.com) Via Della Pace, 11 - 09044 - Quartucciu (CA) - ITALY - www.tecnick.com - info@tecnick.com
|
||||
* @link http://www.tcpdf.org
|
||||
* @license http://www.gnu.org/copyleft/lesser.html LGPL
|
||||
* @version 1.0.005
|
||||
*/
|
||||
|
||||
/**
|
||||
* PHP class to creates array representations for common 1D barcodes to be used with TCPDF (http://www.tcpdf.org).<br>
|
||||
* @name TCPDFBarcode
|
||||
* @package com.tecnick.tcpdf
|
||||
* @version 1.0.005
|
||||
* @author Nicola Asuni
|
||||
* @link http://www.tcpdf.org
|
||||
* @license http://www.gnu.org/copyleft/lesser.html LGPL
|
||||
*/
|
||||
class TCPDFBarcode {
|
||||
|
||||
/**
|
||||
* @var array representation of barcode.
|
||||
* @access protected
|
||||
*/
|
||||
protected $barcode_array;
|
||||
|
||||
/**
|
||||
* This is the class constructor.
|
||||
* Return an array representations for common 1D barcodes:<ul>
|
||||
* <li>$arrcode['code'] code to be printed on text label</li>
|
||||
* <li>$arrcode['maxh'] max bar height</li>
|
||||
* <li>$arrcode['maxw'] max bar width</li>
|
||||
* <li>$arrcode['bcode'][$k] single bar or space in $k position</li>
|
||||
* <li>$arrcode['bcode'][$k]['t'] bar type: true = bar, false = space.</li>
|
||||
* <li>$arrcode['bcode'][$k]['w'] bar width in units.</li>
|
||||
* <li>$arrcode['bcode'][$k]['h'] bar height in units.</li>
|
||||
* <li>$arrcode['bcode'][$k]['p'] bar top position (0 = top, 1 = middle)</li></ul>
|
||||
* @param string $code code to print
|
||||
* @param string $type type of barcode: <ul><li>C39 : CODE 39</li><li>C39+ : CODE 39 with checksum</li><li>C39E : CODE 39 EXTENDED</li><li>C39E+ : CODE 39 EXTENDED with checksum</li><li>I25 : Interleaved 2 of 5</li><li>C128A : CODE 128 A</li><li>C128B : CODE 128 B</li><li>C128C : CODE 128 C</li><li>EAN13 : EAN 13</li><li>UPCA : UPC-A</li><li>POSTNET : POSTNET</li><li>CODABAR : CODABAR</li></ul>
|
||||
*/
|
||||
public function __construct($code, $type) {
|
||||
$this->setBarcode($code, $type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return an array representations of barcode.
|
||||
* @return array
|
||||
*/
|
||||
public function getBarcodeArray() {
|
||||
return $this->barcode_array;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the barcode.
|
||||
* @param string $code code to print
|
||||
* @param string $type type of barcode: <ul><li>C39 : CODE 39</li><li>C39+ : CODE 39 with checksum</li><li>C39E : CODE 39 EXTENDED</li><li>C39E+ : CODE 39 EXTENDED with checksum</li><li>I25 : Interleaved 2 of 5</li><li>C128A : CODE 128 A</li><li>C128B : CODE 128 B</li><li>C128C : CODE 128 C</li><li>EAN13 : EAN 13</li><li>UPCA : UPC-A</li><li>POSTNET : POSTNET</li><li>CODABAR : CODABAR</li></ul>
|
||||
* @return array
|
||||
*/
|
||||
public function setBarcode($code, $type) {
|
||||
switch (strtoupper($type)) {
|
||||
case 'C39': { // CODE 39
|
||||
$arrcode = $this->barcode_code39($code, false, false);
|
||||
break;
|
||||
}
|
||||
case 'C39+': { // CODE 39 with checksum
|
||||
$arrcode = $this->barcode_code39($code, false, true);
|
||||
break;
|
||||
}
|
||||
case 'C39E': { // CODE 39 EXTENDED
|
||||
$arrcode = $this->barcode_code39($code, true, false);
|
||||
break;
|
||||
}
|
||||
case 'C39E+': { // CODE 39 EXTENDED with checksum
|
||||
$arrcode = $this->barcode_code39($code, true, true);
|
||||
break;
|
||||
}
|
||||
case 'I25': { // Interleaved 2 of 5
|
||||
$arrcode = $this->barcode_i25($code);
|
||||
break;
|
||||
}
|
||||
case 'C128A': { // CODE 128 A
|
||||
$arrcode = $this->barcode_c128($code, 'A');
|
||||
break;
|
||||
}
|
||||
case 'C128B': { // CODE 128 B
|
||||
$arrcode = $this->barcode_c128($code, 'B');
|
||||
break;
|
||||
}
|
||||
case 'C128C': { // CODE 128 C
|
||||
$arrcode = $this->barcode_c128($code, 'C');
|
||||
break;
|
||||
}
|
||||
case 'EAN13': { // EAN 13
|
||||
$arrcode = $this->barcode_ean13($code, 13);
|
||||
break;
|
||||
}
|
||||
case 'UPCA': { // UPC-A
|
||||
$arrcode = $this->barcode_ean13($code, 12);
|
||||
break;
|
||||
}
|
||||
case 'POSTNET': { // POSTNET
|
||||
$arrcode = $this->barcode_postnet($code);
|
||||
break;
|
||||
}
|
||||
case 'CODABAR': { // CODABAR
|
||||
$arrcode = $this->barcode_codabar($code);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
$this->barcode_array = false;
|
||||
}
|
||||
}
|
||||
$this->barcode_array = $arrcode;
|
||||
}
|
||||
|
||||
/**
|
||||
* CODE 39
|
||||
* @param string $code code to represent.
|
||||
* @param boolean $checksum if true add a checksum to the code
|
||||
* @return array barcode representation.
|
||||
* @access protected
|
||||
*/
|
||||
protected function barcode_code39($code, $extended=false, $checksum=false) {
|
||||
$chr['0'] = '111221211';
|
||||
$chr['1'] = '211211112';
|
||||
$chr['2'] = '112211112';
|
||||
$chr['3'] = '212211111';
|
||||
$chr['4'] = '111221112';
|
||||
$chr['5'] = '211221111';
|
||||
$chr['6'] = '112221111';
|
||||
$chr['7'] = '111211212';
|
||||
$chr['8'] = '211211211';
|
||||
$chr['9'] = '112211211';
|
||||
$chr['A'] = '211112112';
|
||||
$chr['B'] = '112112112';
|
||||
$chr['C'] = '212112111';
|
||||
$chr['D'] = '111122112';
|
||||
$chr['E'] = '211122111';
|
||||
$chr['F'] = '112122111';
|
||||
$chr['G'] = '111112212';
|
||||
$chr['H'] = '211112211';
|
||||
$chr['I'] = '112112211';
|
||||
$chr['J'] = '111122211';
|
||||
$chr['K'] = '211111122';
|
||||
$chr['L'] = '112111122';
|
||||
$chr['M'] = '212111121';
|
||||
$chr['N'] = '111121122';
|
||||
$chr['O'] = '211121121';
|
||||
$chr['P'] = '112121121';
|
||||
$chr['Q'] = '111111222';
|
||||
$chr['R'] = '211111221';
|
||||
$chr['S'] = '112111221';
|
||||
$chr['T'] = '111121221';
|
||||
$chr['U'] = '221111112';
|
||||
$chr['V'] = '122111112';
|
||||
$chr['W'] = '222111111';
|
||||
$chr['X'] = '121121112';
|
||||
$chr['Y'] = '221121111';
|
||||
$chr['Z'] = '122121111';
|
||||
$chr['-'] = '121111212';
|
||||
$chr['.'] = '221111211';
|
||||
$chr[' '] = '122111211';
|
||||
$chr['*'] = '121121211';
|
||||
$chr['$'] = '121212111';
|
||||
$chr['/'] = '121211121';
|
||||
$chr['+'] = '121112121';
|
||||
$chr['%'] = '111212121';
|
||||
|
||||
$code = strtoupper($code);
|
||||
if ($extended) {
|
||||
// extended mode
|
||||
$code = $this->encode_code39_ext($code);
|
||||
}
|
||||
if ($code === false) {
|
||||
return false;
|
||||
}
|
||||
if ($checksum) {
|
||||
// checksum
|
||||
$code .= $this->checksum_code39($code);
|
||||
}
|
||||
// add start and stop codes
|
||||
$code = '*'.$code.'*';
|
||||
|
||||
$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
|
||||
$k = 0;
|
||||
for($i=0; $i < strlen($code); $i++) {
|
||||
$char = $code{$i};
|
||||
if(!isset($chr[$char])) {
|
||||
// invalid character
|
||||
return false;
|
||||
}
|
||||
for($j=0; $j < 9; $j++) {
|
||||
if (($j % 2) == 0) {
|
||||
$t = true; // bar
|
||||
} else {
|
||||
$t = false; // space
|
||||
}
|
||||
$w = $chr[$char]{$j};
|
||||
$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
|
||||
$bararray['maxw'] += $w;
|
||||
++$k;
|
||||
}
|
||||
$bararray['bcode'][$k] = array('t' => false, 'w' => 1, 'h' => 1, 'p' => 0);
|
||||
$bararray['maxw'] += 1;
|
||||
++$k;
|
||||
}
|
||||
return $bararray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode a string to be used for CODE 39 Extended mode.
|
||||
* @param string $code code to represent.
|
||||
* @return encoded string.
|
||||
* @access protected
|
||||
*/
|
||||
protected function encode_code39_ext($code) {
|
||||
$encode = array(
|
||||
chr(0) => '%U', chr(1) => '$A', chr(2) => '$B', chr(3) => '$C',
|
||||
chr(4) => '$D', chr(5) => '$E', chr(6) => '$F', chr(7) => '$G',
|
||||
chr(8) => '$H', chr(9) => '$I', chr(10) => '$J', chr(11) => '<27>K',
|
||||
chr(12) => '$L', chr(13) => '$M', chr(14) => '$N', chr(15) => '$O',
|
||||
chr(16) => '$P', chr(17) => '$Q', chr(18) => '$R', chr(19) => '$S',
|
||||
chr(20) => '$T', chr(21) => '$U', chr(22) => '$V', chr(23) => '$W',
|
||||
chr(24) => '$X', chr(25) => '$Y', chr(26) => '$Z', chr(27) => '%A',
|
||||
chr(28) => '%B', chr(29) => '%C', chr(30) => '%D', chr(31) => '%E',
|
||||
chr(32) => ' ', chr(33) => '/A', chr(34) => '/B', chr(35) => '/C',
|
||||
chr(36) => '/D', chr(37) => '/E', chr(38) => '/F', chr(39) => '/G',
|
||||
chr(40) => '/H', chr(41) => '/I', chr(42) => '/J', chr(43) => '/K',
|
||||
chr(44) => '/L', chr(45) => '-', chr(46) => '.', chr(47) => '/O',
|
||||
chr(48) => '0', chr(49) => '1', chr(50) => '2', chr(51) => '3',
|
||||
chr(52) => '4', chr(53) => '5', chr(54) => '6', chr(55) => '7',
|
||||
chr(56) => '8', chr(57) => '9', chr(58) => '/Z', chr(59) => '%F',
|
||||
chr(60) => '%G', chr(61) => '%H', chr(62) => '%I', chr(63) => '%J',
|
||||
chr(64) => '%V', chr(65) => 'A', chr(66) => 'B', chr(67) => 'C',
|
||||
chr(68) => 'D', chr(69) => 'E', chr(70) => 'F', chr(71) => 'G',
|
||||
chr(72) => 'H', chr(73) => 'I', chr(74) => 'J', chr(75) => 'K',
|
||||
chr(76) => 'L', chr(77) => 'M', chr(78) => 'N', chr(79) => 'O',
|
||||
chr(80) => 'P', chr(81) => 'Q', chr(82) => 'R', chr(83) => 'S',
|
||||
chr(84) => 'T', chr(85) => 'U', chr(86) => 'V', chr(87) => 'W',
|
||||
chr(88) => 'X', chr(89) => 'Y', chr(90) => 'Z', chr(91) => '%K',
|
||||
chr(92) => '%L', chr(93) => '%M', chr(94) => '%N', chr(95) => '%O',
|
||||
chr(96) => '%W', chr(97) => '+A', chr(98) => '+B', chr(99) => '+C',
|
||||
chr(100) => '+D', chr(101) => '+E', chr(102) => '+F', chr(103) => '+G',
|
||||
chr(104) => '+H', chr(105) => '+I', chr(106) => '+J', chr(107) => '+K',
|
||||
chr(108) => '+L', chr(109) => '+M', chr(110) => '+N', chr(111) => '+O',
|
||||
chr(112) => '+P', chr(113) => '+Q', chr(114) => '+R', chr(115) => '+S',
|
||||
chr(116) => '+T', chr(117) => '+U', chr(118) => '+V', chr(119) => '+W',
|
||||
chr(120) => '+X', chr(121) => '+Y', chr(122) => '+Z', chr(123) => '%P',
|
||||
chr(124) => '%Q', chr(125) => '%R', chr(126) => '%S', chr(127) => '%T');
|
||||
$code_ext = '';
|
||||
for ($i = 0 ; $i < strlen($code); $i++) {
|
||||
if (ord($code{$i}) > 127) {
|
||||
return false;
|
||||
}
|
||||
$code_ext .= $encode[$code{$i}];
|
||||
}
|
||||
return $code_ext;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate CODE 39 checksum (modulo 43).
|
||||
* @param string $code code to represent.
|
||||
* @return char checksum.
|
||||
* @access protected
|
||||
*/
|
||||
protected function checksum_code39($code) {
|
||||
$chars = array(
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
|
||||
'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
|
||||
'W', 'X', 'Y', 'Z', '-', '.', ' ', '$', '/', '+', '%');
|
||||
$sum = 0;
|
||||
for ($i=0 ; $i < strlen($code); $i++) {
|
||||
$k = array_keys($chars, $code{$i});
|
||||
$sum += $k[0];
|
||||
}
|
||||
$j = ($sum % 43);
|
||||
return $chars[$j];
|
||||
}
|
||||
|
||||
/**
|
||||
* Interleaved 2 of 5 barcodes.
|
||||
* Contains digits (0 to 9) and encodes the data in the width of both bars and spaces.
|
||||
* @param string $code code to represent.
|
||||
* @param boolean $checksum if true add a checksum to the code
|
||||
* @return array barcode representation.
|
||||
* @access protected
|
||||
*/
|
||||
protected function barcode_i25($code) {
|
||||
$chr['0'] = '11221';
|
||||
$chr['1'] = '21112';
|
||||
$chr['2'] = '12112';
|
||||
$chr['3'] = '22111';
|
||||
$chr['4'] = '11212';
|
||||
$chr['5'] = '21211';
|
||||
$chr['6'] = '12211';
|
||||
$chr['7'] = '11122';
|
||||
$chr['8'] = '21121';
|
||||
$chr['9'] = '12121';
|
||||
$chr['A'] = '11';
|
||||
$chr['Z'] = '21';
|
||||
|
||||
if((strlen($code) % 2) != 0) {
|
||||
// add leading zero if code-length is odd
|
||||
$code = '0'.$code;
|
||||
}
|
||||
// add start and stop codes
|
||||
$code = 'AA'.strtolower($code).'ZA';
|
||||
|
||||
$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
|
||||
$k = 0;
|
||||
for($i=0; $i < strlen($code); $i=$i+2) {
|
||||
$char_bar = $code{$i};
|
||||
$char_space = $code{$i+1};
|
||||
if((!isset($chr[$char_bar])) OR (!isset($chr[$char_space]))) {
|
||||
// invalid character
|
||||
return false;
|
||||
}
|
||||
// create a bar-space sequence
|
||||
$seq = '';
|
||||
for($s=0; $s < strlen($chr[$char_bar]); $s++){
|
||||
$seq .= $chr[$char_bar]{$s} . $chr[$char_space]{$s};
|
||||
}
|
||||
for($j=0; $j < strlen($seq); $j++) {
|
||||
if (($j % 2) == 0) {
|
||||
$t = true; // bar
|
||||
} else {
|
||||
$t = false; // space
|
||||
}
|
||||
$w = $seq{$j};
|
||||
$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
|
||||
$bararray['maxw'] += $w;
|
||||
++$k;
|
||||
}
|
||||
}
|
||||
return $bararray;
|
||||
}
|
||||
|
||||
/**
|
||||
* C128 barcodes.
|
||||
*
|
||||
* @param string $code code to represent.
|
||||
* @param string $type barcode type: A, B or C
|
||||
* @return array barcode representation.
|
||||
* @access protected
|
||||
*/
|
||||
protected function barcode_c128($code, $type='B') {
|
||||
$chr = array(
|
||||
'212222', /* 00 */
|
||||
'222122', /* 01 */
|
||||
'222221', /* 02 */
|
||||
'121223', /* 03 */
|
||||
'121322', /* 04 */
|
||||
'131222', /* 05 */
|
||||
'122213', /* 06 */
|
||||
'122312', /* 07 */
|
||||
'132212', /* 08 */
|
||||
'221213', /* 09 */
|
||||
'221312', /* 10 */
|
||||
'231212', /* 11 */
|
||||
'112232', /* 12 */
|
||||
'122132', /* 13 */
|
||||
'122231', /* 14 */
|
||||
'113222', /* 15 */
|
||||
'123122', /* 16 */
|
||||
'123221', /* 17 */
|
||||
'223211', /* 18 */
|
||||
'221132', /* 19 */
|
||||
'221231', /* 20 */
|
||||
'213212', /* 21 */
|
||||
'223112', /* 22 */
|
||||
'312131', /* 23 */
|
||||
'311222', /* 24 */
|
||||
'321122', /* 25 */
|
||||
'321221', /* 26 */
|
||||
'312212', /* 27 */
|
||||
'322112', /* 28 */
|
||||
'322211', /* 29 */
|
||||
'212123', /* 30 */
|
||||
'212321', /* 31 */
|
||||
'232121', /* 32 */
|
||||
'111323', /* 33 */
|
||||
'131123', /* 34 */
|
||||
'131321', /* 35 */
|
||||
'112313', /* 36 */
|
||||
'132113', /* 37 */
|
||||
'132311', /* 38 */
|
||||
'211313', /* 39 */
|
||||
'231113', /* 40 */
|
||||
'231311', /* 41 */
|
||||
'112133', /* 42 */
|
||||
'112331', /* 43 */
|
||||
'132131', /* 44 */
|
||||
'113123', /* 45 */
|
||||
'113321', /* 46 */
|
||||
'133121', /* 47 */
|
||||
'313121', /* 48 */
|
||||
'211331', /* 49 */
|
||||
'231131', /* 50 */
|
||||
'213113', /* 51 */
|
||||
'213311', /* 52 */
|
||||
'213131', /* 53 */
|
||||
'311123', /* 54 */
|
||||
'311321', /* 55 */
|
||||
'331121', /* 56 */
|
||||
'312113', /* 57 */
|
||||
'312311', /* 58 */
|
||||
'332111', /* 59 */
|
||||
'314111', /* 60 */
|
||||
'221411', /* 61 */
|
||||
'431111', /* 62 */
|
||||
'111224', /* 63 */
|
||||
'111422', /* 64 */
|
||||
'121124', /* 65 */
|
||||
'121421', /* 66 */
|
||||
'141122', /* 67 */
|
||||
'141221', /* 68 */
|
||||
'112214', /* 69 */
|
||||
'112412', /* 70 */
|
||||
'122114', /* 71 */
|
||||
'122411', /* 72 */
|
||||
'142112', /* 73 */
|
||||
'142211', /* 74 */
|
||||
'241211', /* 75 */
|
||||
'221114', /* 76 */
|
||||
'413111', /* 77 */
|
||||
'241112', /* 78 */
|
||||
'134111', /* 79 */
|
||||
'111242', /* 80 */
|
||||
'121142', /* 81 */
|
||||
'121241', /* 82 */
|
||||
'114212', /* 83 */
|
||||
'124112', /* 84 */
|
||||
'124211', /* 85 */
|
||||
'411212', /* 86 */
|
||||
'421112', /* 87 */
|
||||
'421211', /* 88 */
|
||||
'212141', /* 89 */
|
||||
'214121', /* 90 */
|
||||
'412121', /* 91 */
|
||||
'111143', /* 92 */
|
||||
'111341', /* 93 */
|
||||
'131141', /* 94 */
|
||||
'114113', /* 95 */
|
||||
'114311', /* 96 */
|
||||
'411113', /* 97 */
|
||||
'411311', /* 98 */
|
||||
'113141', /* 99 */
|
||||
'114131', /* 100 */
|
||||
'311141', /* 101 */
|
||||
'411131', /* 102 */
|
||||
'211412', /* 103 START A */
|
||||
'211214', /* 104 START B */
|
||||
'211232', /* 105 START C */
|
||||
'233111', /* STOP */
|
||||
'200000' /* END */
|
||||
);
|
||||
$keys = '';
|
||||
switch(strtoupper($type)) {
|
||||
case 'A': {
|
||||
$startid = 103;
|
||||
$keys = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_';
|
||||
for($i = 0; $i < 32; $i++) {
|
||||
$keys .= chr($i);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'B': {
|
||||
$startid = 104;
|
||||
$keys = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~'.chr(127);
|
||||
break;
|
||||
}
|
||||
case 'C': {
|
||||
$startid = 105;
|
||||
$keys = '';
|
||||
if ((strlen($code) % 2) != 0) {
|
||||
//echo "The length of barcode value must be even ($code). You must pad the number with zeros.\n";
|
||||
return false;
|
||||
}
|
||||
for($i = 0; $i <= 99; $i++) {
|
||||
$keys .= chr($i);
|
||||
}
|
||||
$new_code = '';
|
||||
for ($i=0; $i < (strlen($code) / 2); $i++) {
|
||||
$new_code .= chr(intval($code{(2 * $i)}.$code{(2 * $i + 1)}));
|
||||
}
|
||||
$code = $new_code;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// calculate check character
|
||||
$sum = $startid;
|
||||
for ($i=0; $i < strlen($code); $i++) {
|
||||
$sum += (strpos($keys, $code{$i}) * ($i+1));
|
||||
}
|
||||
$check = ($sum % 103);
|
||||
|
||||
// add start, check and stop codes
|
||||
$code = chr($startid).$code.chr($check).chr(106).chr(107);
|
||||
$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
|
||||
$k = 0;
|
||||
$len = strlen($code);
|
||||
for($i=0; $i < $len; $i++) {
|
||||
$ck = strpos($keys, $code{$i});
|
||||
if (($i == 0) OR ($i > ($len-4))) {
|
||||
$char_num = ord($code{$i});
|
||||
$seq = $chr[$char_num];
|
||||
} elseif(($ck >= 0) AND isset($chr[$ck])) {
|
||||
$seq = $chr[$ck];
|
||||
} else {
|
||||
// invalid character
|
||||
return false;
|
||||
}
|
||||
for($j=0; $j < 6; $j++) {
|
||||
if (($j % 2) == 0) {
|
||||
$t = true; // bar
|
||||
} else {
|
||||
$t = false; // space
|
||||
}
|
||||
$w = $seq{$j};
|
||||
$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
|
||||
$bararray['maxw'] += $w;
|
||||
++$k;
|
||||
}
|
||||
}
|
||||
return $bararray;
|
||||
}
|
||||
|
||||
/**
|
||||
* EAN13 and UPC-A barcodes.
|
||||
* @param string $code code to represent.
|
||||
* @param string $len barcode type: 13 = EAN13, 12 = UPC-A
|
||||
* @return array barcode representation.
|
||||
* @access protected
|
||||
*/
|
||||
protected function barcode_ean13($code, $len=13) {
|
||||
//Padding
|
||||
$code = str_pad($code, $len-1, '0', STR_PAD_LEFT);
|
||||
if($len == 12) {
|
||||
$code = '0'.$code;
|
||||
}
|
||||
// add check digit
|
||||
if(strlen($code) == 12) {
|
||||
$sum=0;
|
||||
for($i=1;$i<=11;$i+=2) {
|
||||
$sum += (3 * $code{$i});
|
||||
}
|
||||
for($i=0; $i <= 10; $i+=2) {
|
||||
$sum += ($code{$i});
|
||||
}
|
||||
$r = $sum % 10;
|
||||
if($r > 0) {
|
||||
$r = (10 - $r);
|
||||
}
|
||||
$code .= $r;
|
||||
} else { // test checkdigit
|
||||
$sum = 0;
|
||||
for($i=1; $i <= 11; $i+=2) {
|
||||
$sum += (3 * $code{$i});
|
||||
}
|
||||
for($i=0; $i <= 10; $i+=2) {
|
||||
$sum += $code{$i};
|
||||
}
|
||||
if ((($sum + $code{12}) % 10) != 0) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
//Convert digits to bars
|
||||
$codes = array(
|
||||
'A'=>array(
|
||||
'0'=>'0001101',
|
||||
'1'=>'0011001',
|
||||
'2'=>'0010011',
|
||||
'3'=>'0111101',
|
||||
'4'=>'0100011',
|
||||
'5'=>'0110001',
|
||||
'6'=>'0101111',
|
||||
'7'=>'0111011',
|
||||
'8'=>'0110111',
|
||||
'9'=>'0001011'),
|
||||
'B'=>array(
|
||||
'0'=>'0100111',
|
||||
'1'=>'0110011',
|
||||
'2'=>'0011011',
|
||||
'3'=>'0100001',
|
||||
'4'=>'0011101',
|
||||
'5'=>'0111001',
|
||||
'6'=>'0000101',
|
||||
'7'=>'0010001',
|
||||
'8'=>'0001001',
|
||||
'9'=>'0010111'),
|
||||
'C'=>array(
|
||||
'0'=>'1110010',
|
||||
'1'=>'1100110',
|
||||
'2'=>'1101100',
|
||||
'3'=>'1000010',
|
||||
'4'=>'1011100',
|
||||
'5'=>'1001110',
|
||||
'6'=>'1010000',
|
||||
'7'=>'1000100',
|
||||
'8'=>'1001000',
|
||||
'9'=>'1110100')
|
||||
);
|
||||
$parities = array(
|
||||
'0'=>array('A','A','A','A','A','A'),
|
||||
'1'=>array('A','A','B','A','B','B'),
|
||||
'2'=>array('A','A','B','B','A','B'),
|
||||
'3'=>array('A','A','B','B','B','A'),
|
||||
'4'=>array('A','B','A','A','B','B'),
|
||||
'5'=>array('A','B','B','A','A','B'),
|
||||
'6'=>array('A','B','B','B','A','A'),
|
||||
'7'=>array('A','B','A','B','A','B'),
|
||||
'8'=>array('A','B','A','B','B','A'),
|
||||
'9'=>array('A','B','B','A','B','A')
|
||||
);
|
||||
|
||||
$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
|
||||
$k = 0;
|
||||
$seq = '101';
|
||||
$p = $parities[$code{0}];
|
||||
for($i=1; $i < 7; $i++) {
|
||||
$seq .= $codes[$p[$i-1]][$code{$i}];
|
||||
}
|
||||
$seq .= '01010';
|
||||
for($i=7; $i < 13; $i++) {
|
||||
$seq .= $codes['C'][$code{$i}];
|
||||
}
|
||||
$seq .= '101';
|
||||
$len = strlen($seq);
|
||||
$w = 0;
|
||||
for($i=0; $i < $len; $i++) {
|
||||
$w += 1;
|
||||
if (($i == ($len - 1)) OR (($i < ($len - 1)) AND ($seq{$i} != $seq{($i+1)}))) {
|
||||
if ($seq{$i} == '1') {
|
||||
$t = true; // bar
|
||||
} else {
|
||||
$t = false; // space
|
||||
}
|
||||
$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
|
||||
$bararray['maxw'] += $w;
|
||||
++$k;
|
||||
$w = 0;
|
||||
}
|
||||
}
|
||||
return $bararray;
|
||||
}
|
||||
|
||||
/**
|
||||
* POSTNET barcodes.
|
||||
* @param string $code zip code to represent. Must be a string containing a zip code of the form DDDDD or DDDDD-DDDD.
|
||||
* @return array barcode representation.
|
||||
* @access protected
|
||||
*/
|
||||
protected function barcode_postnet($code) {
|
||||
// bar lenght
|
||||
$barlen = Array(
|
||||
0 => Array(2,2,1,1,1),
|
||||
1 => Array(1,1,1,2,2),
|
||||
2 => Array(1,1,2,1,2),
|
||||
3 => Array(1,1,2,2,1),
|
||||
4 => Array(1,2,1,1,2),
|
||||
5 => Array(1,2,1,2,1),
|
||||
6 => Array(1,2,2,1,1),
|
||||
7 => Array(2,1,1,1,2),
|
||||
8 => Array(2,1,1,2,1),
|
||||
9 => Array(2,1,2,1,1)
|
||||
);
|
||||
$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 2, 'bcode' => array());
|
||||
$k = 0;
|
||||
$code = str_replace('-', '', $code);
|
||||
$code = str_replace(' ', '', $code);
|
||||
$len = strlen($code);
|
||||
// calculate checksum
|
||||
$sum = 0;
|
||||
for($i=0; $i < $len; $i++) {
|
||||
$sum += intval($code{$i});
|
||||
}
|
||||
$chkd = ($sum % 10);
|
||||
if($chkd > 0) {
|
||||
$chkd = (10 - $chkd);
|
||||
}
|
||||
$code .= $chkd;
|
||||
$len = strlen($code);
|
||||
// start bar
|
||||
$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => 2, 'p' => 0);
|
||||
$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
|
||||
$bararray['maxw'] += 2;
|
||||
for ($i=0; $i < $len; $i++) {
|
||||
for ($j=0; $j < 5; $j++) {
|
||||
$h = $barlen[$code{$i}][$j];
|
||||
$p = floor(1 / $h);
|
||||
$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => $h, 'p' => $p);
|
||||
$bararray['bcode'][$k++] = array('t' => 0, 'w' => 1, 'h' => 2, 'p' => 0);
|
||||
$bararray['maxw'] += 2;
|
||||
}
|
||||
}
|
||||
// end bar
|
||||
$bararray['bcode'][$k++] = array('t' => 1, 'w' => 1, 'h' => 2, 'p' => 0);
|
||||
$bararray['maxw'] += 1;
|
||||
return $bararray;
|
||||
}
|
||||
|
||||
/**
|
||||
* CODABAR barcodes.
|
||||
* @param string $code code to represent.
|
||||
* @return array barcode representation.
|
||||
* @access protected
|
||||
*/
|
||||
protected function barcode_codabar($code) {
|
||||
$chr = array(
|
||||
'0' => '11111221',
|
||||
'1' => '11112211',
|
||||
'2' => '11121121',
|
||||
'3' => '22111111',
|
||||
'4' => '11211211',
|
||||
'5' => '21111211',
|
||||
'6' => '12111121',
|
||||
'7' => '12112111',
|
||||
'8' => '12211111',
|
||||
'9' => '21121111',
|
||||
'-' => '11122111',
|
||||
'$' => '11221111',
|
||||
':' => '21112121',
|
||||
'/' => '21211121',
|
||||
'.' => '21212111',
|
||||
'+' => '11222221',
|
||||
'A' => '11221211',
|
||||
'B' => '12121121',
|
||||
'C' => '11121221',
|
||||
'D' => '11122211'
|
||||
);
|
||||
|
||||
$bararray = array('code' => $code, 'maxw' => 0, 'maxh' => 1, 'bcode' => array());
|
||||
$k = 0;
|
||||
$w = 0;
|
||||
$seq = '';
|
||||
$code = 'A'.strtoupper($code).'A';
|
||||
$len = strlen($code);
|
||||
for($i=0; $i < $len; $i++) {
|
||||
if (!isset($chr[$code{$i}])) {
|
||||
return false;
|
||||
}
|
||||
$seq = $chr[$code{$i}];
|
||||
for($j=0; $j < 8; $j++) {
|
||||
if (($j % 2) == 0) {
|
||||
$t = true; // bar
|
||||
} else {
|
||||
$t = false; // space
|
||||
}
|
||||
$w = $seq{$j};
|
||||
$bararray['bcode'][$k] = array('t' => $t, 'w' => $w, 'h' => 1, 'p' => 0);
|
||||
$bararray['maxw'] += $w;
|
||||
++$k;
|
||||
}
|
||||
}
|
||||
return $bararray;
|
||||
}
|
||||
|
||||
} // end of class
|
||||
|
||||
//============================================================+
|
||||
// END OF FILE
|
||||
//============================================================+
|
||||
?>
|
||||
50
include/PHPExcel/PHPExcel/Shared/PDF/config/lang/eng.php
Executable file
50
include/PHPExcel/PHPExcel/Shared/PDF/config/lang/eng.php
Executable file
@@ -0,0 +1,50 @@
|
||||
<?php
|
||||
//============================================================+
|
||||
// File name : eng.php
|
||||
// Begin : 2004-03-03
|
||||
// Last Update : 2008-11-17
|
||||
//
|
||||
// Description : Language module for TCPDF
|
||||
// (contains translated texts)
|
||||
//
|
||||
// Author: Nicola Asuni
|
||||
//
|
||||
// (c) Copyright:
|
||||
// Nicola Asuni
|
||||
// Tecnick.com s.r.l.
|
||||
// Via Della Pace, 11
|
||||
// 09044 Quartucciu (CA)
|
||||
// ITALY
|
||||
// www.tecnick.com
|
||||
// info@tecnick.com
|
||||
//============================================================+
|
||||
|
||||
/**
|
||||
* TCPDF language file (contains translated texts).
|
||||
* @package com.tecnick.tcpdf
|
||||
* @abstract TCPDF language file.
|
||||
* @author Nicola Asuni
|
||||
* @copyright 2004-2009 Nicola Asuni - Tecnick.com S.r.l (www.tecnick.com) Via Della Pace, 11 - 09044 - Quartucciu (CA) - ITALY - www.tecnick.com - info@tecnick.com
|
||||
* @link http://tcpdf.sourceforge.net
|
||||
* @license http://www.gnu.org/copyleft/lesser.html LGPL
|
||||
* @since 2004-03-03
|
||||
*/
|
||||
|
||||
// ENGLISH
|
||||
|
||||
global $l;
|
||||
$l = Array();
|
||||
|
||||
// PAGE META DESCRIPTORS --------------------------------------
|
||||
|
||||
$l['a_meta_charset'] = 'UTF-8';
|
||||
$l['a_meta_dir'] = 'ltr';
|
||||
$l['a_meta_language'] = 'en';
|
||||
|
||||
// TRANSLATIONS --------------------------------------
|
||||
$l['w_page'] = 'page';
|
||||
|
||||
//============================================================+
|
||||
// END OF FILE
|
||||
//============================================================+
|
||||
?>
|
||||
227
include/PHPExcel/PHPExcel/Shared/PDF/config/tcpdf_config.php
Executable file
227
include/PHPExcel/PHPExcel/Shared/PDF/config/tcpdf_config.php
Executable file
@@ -0,0 +1,227 @@
|
||||
<?php
|
||||
//============================================================+
|
||||
// File name : tcpdf_config.php
|
||||
// Begin : 2004-06-11
|
||||
// Last Update : 2008-11-17
|
||||
//
|
||||
// Description : Configuration file for TCPDF.
|
||||
//
|
||||
// Author: Nicola Asuni
|
||||
//
|
||||
// (c) Copyright:
|
||||
// Nicola Asuni
|
||||
// Tecnick.com s.r.l.
|
||||
// Via Della Pace, 11
|
||||
// 09044 Quartucciu (CA)
|
||||
// ITALY
|
||||
// www.tecnick.com
|
||||
// info@tecnick.com
|
||||
//============================================================+
|
||||
|
||||
/**
|
||||
* Configuration file for TCPDF.
|
||||
* @author Nicola Asuni
|
||||
* @copyright 2004-2009 Nicola Asuni - Tecnick.com S.r.l (www.tecnick.com) Via Della Pace, 11 - 09044 - Quartucciu (CA) - ITALY - www.tecnick.com - info@tecnick.com
|
||||
* @package com.tecnick.tcpdf
|
||||
* @version 4.0.014
|
||||
* @link http://tcpdf.sourceforge.net
|
||||
* @license http://www.gnu.org/copyleft/lesser.html LGPL
|
||||
* @since 2004-10-27
|
||||
*/
|
||||
|
||||
// If you define the constant K_TCPDF_EXTERNAL_CONFIG, the following settings will be ignored.
|
||||
|
||||
if (!defined('K_TCPDF_EXTERNAL_CONFIG')) {
|
||||
|
||||
// DOCUMENT_ROOT fix for IIS Webserver
|
||||
if ((!isset($_SERVER['DOCUMENT_ROOT'])) OR (empty($_SERVER['DOCUMENT_ROOT']))) {
|
||||
if(isset($_SERVER['SCRIPT_FILENAME'])) {
|
||||
$_SERVER['DOCUMENT_ROOT'] = str_replace( '\\', '/', substr($_SERVER['SCRIPT_FILENAME'], 0, 0-strlen($_SERVER['PHP_SELF'])));
|
||||
} elseif(isset($_SERVER['PATH_TRANSLATED'])) {
|
||||
$_SERVER['DOCUMENT_ROOT'] = str_replace( '\\', '/', substr(str_replace('\\\\', '\\', $_SERVER['PATH_TRANSLATED']), 0, 0-strlen($_SERVER['PHP_SELF'])));
|
||||
} else {
|
||||
// define here your DOCUMENT_ROOT path if the previous fails
|
||||
$_SERVER['DOCUMENT_ROOT'] = '/var/www';
|
||||
}
|
||||
}
|
||||
|
||||
// Automatic calculation for the following K_PATH_MAIN constant
|
||||
$k_path_main = str_replace( '\\', '/', realpath(substr(dirname(__FILE__), 0, 0-strlen('config'))));
|
||||
if (substr($k_path_main, -1) != '/') {
|
||||
$k_path_main .= '/';
|
||||
}
|
||||
|
||||
/**
|
||||
* Installation path (/var/www/html/e5crm/tcpdf/).
|
||||
* By default it is automatically calculated but you can also set it as a fixed string to improve performances.
|
||||
*/
|
||||
define ('K_PATH_MAIN', $k_path_main);
|
||||
|
||||
// Automatic calculation for the following K_PATH_URL constant
|
||||
if (isset($_SERVER['HTTP_HOST']) AND (!empty($_SERVER['HTTP_HOST']))) {
|
||||
if(isset($_SERVER['HTTPS']) AND (!empty($_SERVER['HTTPS'])) AND strtolower($_SERVER['HTTPS'])!='off') {
|
||||
$k_path_url = 'https://';
|
||||
} else {
|
||||
$k_path_url = 'http://';
|
||||
}
|
||||
$k_path_url .= $_SERVER['HTTP_HOST'];
|
||||
$k_path_url .= str_replace( '\\', '/', substr($_SERVER['PHP_SELF'], 0, -24));
|
||||
}
|
||||
|
||||
/**
|
||||
* URL path to tcpdf installation folder (http://localhost/tcpdf/).
|
||||
* By default it is automatically calculated but you can also set it as a fixed string to improve performances..
|
||||
*/
|
||||
define ('K_PATH_URL', $k_path_url);
|
||||
|
||||
/**
|
||||
* path for PDF fonts
|
||||
* use K_PATH_MAIN.'fonts/old/' for old non-UTF8 fonts
|
||||
*/
|
||||
define ('K_PATH_FONTS', K_PATH_MAIN.'fonts/');
|
||||
|
||||
/**
|
||||
* cache directory for temporary files (full path)
|
||||
*/
|
||||
define ('K_PATH_CACHE', K_PATH_MAIN.'cache/');
|
||||
|
||||
/**
|
||||
* cache directory for temporary files (url path)
|
||||
*/
|
||||
define ('K_PATH_URL_CACHE', K_PATH_URL.'cache/');
|
||||
|
||||
/**
|
||||
*images directory
|
||||
*/
|
||||
define ('K_PATH_IMAGES', K_PATH_MAIN.'images/');
|
||||
|
||||
/**
|
||||
* blank image
|
||||
*/
|
||||
define ('K_BLANK_IMAGE', K_PATH_IMAGES.'_blank.png');
|
||||
|
||||
/**
|
||||
* page format
|
||||
*/
|
||||
define ('PDF_PAGE_FORMAT', 'A4');
|
||||
|
||||
/**
|
||||
* page orientation (P=portrait, L=landscape)
|
||||
*/
|
||||
define ('PDF_PAGE_ORIENTATION', 'P');
|
||||
|
||||
/**
|
||||
* document creator
|
||||
*/
|
||||
define ('PDF_CREATOR', 'TCPDF');
|
||||
|
||||
/**
|
||||
* document author
|
||||
*/
|
||||
define ('PDF_AUTHOR', 'TCPDF');
|
||||
|
||||
/**
|
||||
* header title
|
||||
*/
|
||||
define ('PDF_HEADER_TITLE', 'TCPDF Example');
|
||||
|
||||
/**
|
||||
* header description string
|
||||
*/
|
||||
define ('PDF_HEADER_STRING', "by Nicola Asuni - Tecnick.com\nwww.tcpdf.org");
|
||||
|
||||
/**
|
||||
* image logo
|
||||
*/
|
||||
define ('PDF_HEADER_LOGO', 'tcpdf_logo.jpg');
|
||||
|
||||
/**
|
||||
* header logo image width [mm]
|
||||
*/
|
||||
define ('PDF_HEADER_LOGO_WIDTH', 30);
|
||||
|
||||
/**
|
||||
* document unit of measure [pt=point, mm=millimeter, cm=centimeter, in=inch]
|
||||
*/
|
||||
define ('PDF_UNIT', 'mm');
|
||||
|
||||
/**
|
||||
* header margin
|
||||
*/
|
||||
define ('PDF_MARGIN_HEADER', 5);
|
||||
|
||||
/**
|
||||
* footer margin
|
||||
*/
|
||||
define ('PDF_MARGIN_FOOTER', 10);
|
||||
|
||||
/**
|
||||
* top margin
|
||||
*/
|
||||
define ('PDF_MARGIN_TOP', 27);
|
||||
|
||||
/**
|
||||
* bottom margin
|
||||
*/
|
||||
define ('PDF_MARGIN_BOTTOM', 25);
|
||||
|
||||
/**
|
||||
* left margin
|
||||
*/
|
||||
define ('PDF_MARGIN_LEFT', 15);
|
||||
|
||||
/**
|
||||
* right margin
|
||||
*/
|
||||
define ('PDF_MARGIN_RIGHT', 15);
|
||||
|
||||
/**
|
||||
* main font name
|
||||
*/
|
||||
define ('PDF_FONT_NAME_MAIN', 'helvetica');
|
||||
|
||||
/**
|
||||
* main font size
|
||||
*/
|
||||
define ('PDF_FONT_SIZE_MAIN', 10);
|
||||
|
||||
/**
|
||||
* data font name
|
||||
*/
|
||||
define ('PDF_FONT_NAME_DATA', 'helvetica');
|
||||
|
||||
/**
|
||||
* data font size
|
||||
*/
|
||||
define ('PDF_FONT_SIZE_DATA', 8);
|
||||
|
||||
/**
|
||||
* Ratio used to scale the images
|
||||
*/
|
||||
define ('PDF_IMAGE_SCALE_RATIO', 4);
|
||||
|
||||
/**
|
||||
* magnification factor for titles
|
||||
*/
|
||||
define('HEAD_MAGNIFICATION', 1.1);
|
||||
|
||||
/**
|
||||
* height of cell repect font height
|
||||
*/
|
||||
define('K_CELL_HEIGHT_RATIO', 1.25);
|
||||
|
||||
/**
|
||||
* title magnification respect main font size
|
||||
*/
|
||||
define('K_TITLE_MAGNIFICATION', 1.3);
|
||||
|
||||
/**
|
||||
* reduction factor for small font
|
||||
*/
|
||||
define('K_SMALL_RATIO', 2/3);
|
||||
}
|
||||
|
||||
//============================================================+
|
||||
// END OF FILE
|
||||
//============================================================+
|
||||
?>
|
||||
7
include/PHPExcel/PHPExcel/Shared/PDF/font/courier.php
Executable file
7
include/PHPExcel/PHPExcel/Shared/PDF/font/courier.php
Executable file
@@ -0,0 +1,7 @@
|
||||
<?php
|
||||
for($i=0;$i<=255;++$i)
|
||||
$fpdf_charwidths['courier'][chr($i)]=600;
|
||||
$fpdf_charwidths['courierB']=$fpdf_charwidths['courier'];
|
||||
$fpdf_charwidths['courierI']=$fpdf_charwidths['courier'];
|
||||
$fpdf_charwidths['courierBI']=$fpdf_charwidths['courier'];
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helvetica.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helvetica.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['helvetica']=array(
|
||||
chr(0)=>278,chr(1)=>278,chr(2)=>278,chr(3)=>278,chr(4)=>278,chr(5)=>278,chr(6)=>278,chr(7)=>278,chr(8)=>278,chr(9)=>278,chr(10)=>278,chr(11)=>278,chr(12)=>278,chr(13)=>278,chr(14)=>278,chr(15)=>278,chr(16)=>278,chr(17)=>278,chr(18)=>278,chr(19)=>278,chr(20)=>278,chr(21)=>278,
|
||||
chr(22)=>278,chr(23)=>278,chr(24)=>278,chr(25)=>278,chr(26)=>278,chr(27)=>278,chr(28)=>278,chr(29)=>278,chr(30)=>278,chr(31)=>278,' '=>278,'!'=>278,'"'=>355,'#'=>556,'$'=>556,'%'=>889,'&'=>667,'\''=>191,'('=>333,')'=>333,'*'=>389,'+'=>584,
|
||||
','=>278,'-'=>333,'.'=>278,'/'=>278,'0'=>556,'1'=>556,'2'=>556,'3'=>556,'4'=>556,'5'=>556,'6'=>556,'7'=>556,'8'=>556,'9'=>556,':'=>278,';'=>278,'<'=>584,'='=>584,'>'=>584,'?'=>556,'@'=>1015,'A'=>667,
|
||||
'B'=>667,'C'=>722,'D'=>722,'E'=>667,'F'=>611,'G'=>778,'H'=>722,'I'=>278,'J'=>500,'K'=>667,'L'=>556,'M'=>833,'N'=>722,'O'=>778,'P'=>667,'Q'=>778,'R'=>722,'S'=>667,'T'=>611,'U'=>722,'V'=>667,'W'=>944,
|
||||
'X'=>667,'Y'=>667,'Z'=>611,'['=>278,'\\'=>278,']'=>278,'^'=>469,'_'=>556,'`'=>333,'a'=>556,'b'=>556,'c'=>500,'d'=>556,'e'=>556,'f'=>278,'g'=>556,'h'=>556,'i'=>222,'j'=>222,'k'=>500,'l'=>222,'m'=>833,
|
||||
'n'=>556,'o'=>556,'p'=>556,'q'=>556,'r'=>333,'s'=>500,'t'=>278,'u'=>556,'v'=>500,'w'=>722,'x'=>500,'y'=>500,'z'=>500,'{'=>334,'|'=>260,'}'=>334,'~'=>584,chr(127)=>350,chr(128)=>556,chr(129)=>350,chr(130)=>222,chr(131)=>556,
|
||||
chr(132)=>333,chr(133)=>1000,chr(134)=>556,chr(135)=>556,chr(136)=>333,chr(137)=>1000,chr(138)=>667,chr(139)=>333,chr(140)=>1000,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>222,chr(146)=>222,chr(147)=>333,chr(148)=>333,chr(149)=>350,chr(150)=>556,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
|
||||
chr(154)=>500,chr(155)=>333,chr(156)=>944,chr(157)=>350,chr(158)=>500,chr(159)=>667,chr(160)=>278,chr(161)=>333,chr(162)=>556,chr(163)=>556,chr(164)=>556,chr(165)=>556,chr(166)=>260,chr(167)=>556,chr(168)=>333,chr(169)=>737,chr(170)=>370,chr(171)=>556,chr(172)=>584,chr(173)=>333,chr(174)=>737,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>584,chr(178)=>333,chr(179)=>333,chr(180)=>333,chr(181)=>556,chr(182)=>537,chr(183)=>278,chr(184)=>333,chr(185)=>333,chr(186)=>365,chr(187)=>556,chr(188)=>834,chr(189)=>834,chr(190)=>834,chr(191)=>611,chr(192)=>667,chr(193)=>667,chr(194)=>667,chr(195)=>667,chr(196)=>667,chr(197)=>667,
|
||||
chr(198)=>1000,chr(199)=>722,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>278,chr(205)=>278,chr(206)=>278,chr(207)=>278,chr(208)=>722,chr(209)=>722,chr(210)=>778,chr(211)=>778,chr(212)=>778,chr(213)=>778,chr(214)=>778,chr(215)=>584,chr(216)=>778,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>667,chr(222)=>667,chr(223)=>611,chr(224)=>556,chr(225)=>556,chr(226)=>556,chr(227)=>556,chr(228)=>556,chr(229)=>556,chr(230)=>889,chr(231)=>500,chr(232)=>556,chr(233)=>556,chr(234)=>556,chr(235)=>556,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>556,chr(241)=>556,
|
||||
chr(242)=>556,chr(243)=>556,chr(244)=>556,chr(245)=>556,chr(246)=>556,chr(247)=>584,chr(248)=>611,chr(249)=>556,chr(250)=>556,chr(251)=>556,chr(252)=>556,chr(253)=>500,chr(254)=>556,chr(255)=>500);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helveticab.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helveticab.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['helveticaB']=array(
|
||||
chr(0)=>278,chr(1)=>278,chr(2)=>278,chr(3)=>278,chr(4)=>278,chr(5)=>278,chr(6)=>278,chr(7)=>278,chr(8)=>278,chr(9)=>278,chr(10)=>278,chr(11)=>278,chr(12)=>278,chr(13)=>278,chr(14)=>278,chr(15)=>278,chr(16)=>278,chr(17)=>278,chr(18)=>278,chr(19)=>278,chr(20)=>278,chr(21)=>278,
|
||||
chr(22)=>278,chr(23)=>278,chr(24)=>278,chr(25)=>278,chr(26)=>278,chr(27)=>278,chr(28)=>278,chr(29)=>278,chr(30)=>278,chr(31)=>278,' '=>278,'!'=>333,'"'=>474,'#'=>556,'$'=>556,'%'=>889,'&'=>722,'\''=>238,'('=>333,')'=>333,'*'=>389,'+'=>584,
|
||||
','=>278,'-'=>333,'.'=>278,'/'=>278,'0'=>556,'1'=>556,'2'=>556,'3'=>556,'4'=>556,'5'=>556,'6'=>556,'7'=>556,'8'=>556,'9'=>556,':'=>333,';'=>333,'<'=>584,'='=>584,'>'=>584,'?'=>611,'@'=>975,'A'=>722,
|
||||
'B'=>722,'C'=>722,'D'=>722,'E'=>667,'F'=>611,'G'=>778,'H'=>722,'I'=>278,'J'=>556,'K'=>722,'L'=>611,'M'=>833,'N'=>722,'O'=>778,'P'=>667,'Q'=>778,'R'=>722,'S'=>667,'T'=>611,'U'=>722,'V'=>667,'W'=>944,
|
||||
'X'=>667,'Y'=>667,'Z'=>611,'['=>333,'\\'=>278,']'=>333,'^'=>584,'_'=>556,'`'=>333,'a'=>556,'b'=>611,'c'=>556,'d'=>611,'e'=>556,'f'=>333,'g'=>611,'h'=>611,'i'=>278,'j'=>278,'k'=>556,'l'=>278,'m'=>889,
|
||||
'n'=>611,'o'=>611,'p'=>611,'q'=>611,'r'=>389,'s'=>556,'t'=>333,'u'=>611,'v'=>556,'w'=>778,'x'=>556,'y'=>556,'z'=>500,'{'=>389,'|'=>280,'}'=>389,'~'=>584,chr(127)=>350,chr(128)=>556,chr(129)=>350,chr(130)=>278,chr(131)=>556,
|
||||
chr(132)=>500,chr(133)=>1000,chr(134)=>556,chr(135)=>556,chr(136)=>333,chr(137)=>1000,chr(138)=>667,chr(139)=>333,chr(140)=>1000,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>278,chr(146)=>278,chr(147)=>500,chr(148)=>500,chr(149)=>350,chr(150)=>556,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
|
||||
chr(154)=>556,chr(155)=>333,chr(156)=>944,chr(157)=>350,chr(158)=>500,chr(159)=>667,chr(160)=>278,chr(161)=>333,chr(162)=>556,chr(163)=>556,chr(164)=>556,chr(165)=>556,chr(166)=>280,chr(167)=>556,chr(168)=>333,chr(169)=>737,chr(170)=>370,chr(171)=>556,chr(172)=>584,chr(173)=>333,chr(174)=>737,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>584,chr(178)=>333,chr(179)=>333,chr(180)=>333,chr(181)=>611,chr(182)=>556,chr(183)=>278,chr(184)=>333,chr(185)=>333,chr(186)=>365,chr(187)=>556,chr(188)=>834,chr(189)=>834,chr(190)=>834,chr(191)=>611,chr(192)=>722,chr(193)=>722,chr(194)=>722,chr(195)=>722,chr(196)=>722,chr(197)=>722,
|
||||
chr(198)=>1000,chr(199)=>722,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>278,chr(205)=>278,chr(206)=>278,chr(207)=>278,chr(208)=>722,chr(209)=>722,chr(210)=>778,chr(211)=>778,chr(212)=>778,chr(213)=>778,chr(214)=>778,chr(215)=>584,chr(216)=>778,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>667,chr(222)=>667,chr(223)=>611,chr(224)=>556,chr(225)=>556,chr(226)=>556,chr(227)=>556,chr(228)=>556,chr(229)=>556,chr(230)=>889,chr(231)=>556,chr(232)=>556,chr(233)=>556,chr(234)=>556,chr(235)=>556,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>611,chr(241)=>611,
|
||||
chr(242)=>611,chr(243)=>611,chr(244)=>611,chr(245)=>611,chr(246)=>611,chr(247)=>584,chr(248)=>611,chr(249)=>611,chr(250)=>611,chr(251)=>611,chr(252)=>611,chr(253)=>556,chr(254)=>611,chr(255)=>556);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helveticabi.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helveticabi.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['helveticaBI']=array(
|
||||
chr(0)=>278,chr(1)=>278,chr(2)=>278,chr(3)=>278,chr(4)=>278,chr(5)=>278,chr(6)=>278,chr(7)=>278,chr(8)=>278,chr(9)=>278,chr(10)=>278,chr(11)=>278,chr(12)=>278,chr(13)=>278,chr(14)=>278,chr(15)=>278,chr(16)=>278,chr(17)=>278,chr(18)=>278,chr(19)=>278,chr(20)=>278,chr(21)=>278,
|
||||
chr(22)=>278,chr(23)=>278,chr(24)=>278,chr(25)=>278,chr(26)=>278,chr(27)=>278,chr(28)=>278,chr(29)=>278,chr(30)=>278,chr(31)=>278,' '=>278,'!'=>333,'"'=>474,'#'=>556,'$'=>556,'%'=>889,'&'=>722,'\''=>238,'('=>333,')'=>333,'*'=>389,'+'=>584,
|
||||
','=>278,'-'=>333,'.'=>278,'/'=>278,'0'=>556,'1'=>556,'2'=>556,'3'=>556,'4'=>556,'5'=>556,'6'=>556,'7'=>556,'8'=>556,'9'=>556,':'=>333,';'=>333,'<'=>584,'='=>584,'>'=>584,'?'=>611,'@'=>975,'A'=>722,
|
||||
'B'=>722,'C'=>722,'D'=>722,'E'=>667,'F'=>611,'G'=>778,'H'=>722,'I'=>278,'J'=>556,'K'=>722,'L'=>611,'M'=>833,'N'=>722,'O'=>778,'P'=>667,'Q'=>778,'R'=>722,'S'=>667,'T'=>611,'U'=>722,'V'=>667,'W'=>944,
|
||||
'X'=>667,'Y'=>667,'Z'=>611,'['=>333,'\\'=>278,']'=>333,'^'=>584,'_'=>556,'`'=>333,'a'=>556,'b'=>611,'c'=>556,'d'=>611,'e'=>556,'f'=>333,'g'=>611,'h'=>611,'i'=>278,'j'=>278,'k'=>556,'l'=>278,'m'=>889,
|
||||
'n'=>611,'o'=>611,'p'=>611,'q'=>611,'r'=>389,'s'=>556,'t'=>333,'u'=>611,'v'=>556,'w'=>778,'x'=>556,'y'=>556,'z'=>500,'{'=>389,'|'=>280,'}'=>389,'~'=>584,chr(127)=>350,chr(128)=>556,chr(129)=>350,chr(130)=>278,chr(131)=>556,
|
||||
chr(132)=>500,chr(133)=>1000,chr(134)=>556,chr(135)=>556,chr(136)=>333,chr(137)=>1000,chr(138)=>667,chr(139)=>333,chr(140)=>1000,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>278,chr(146)=>278,chr(147)=>500,chr(148)=>500,chr(149)=>350,chr(150)=>556,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
|
||||
chr(154)=>556,chr(155)=>333,chr(156)=>944,chr(157)=>350,chr(158)=>500,chr(159)=>667,chr(160)=>278,chr(161)=>333,chr(162)=>556,chr(163)=>556,chr(164)=>556,chr(165)=>556,chr(166)=>280,chr(167)=>556,chr(168)=>333,chr(169)=>737,chr(170)=>370,chr(171)=>556,chr(172)=>584,chr(173)=>333,chr(174)=>737,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>584,chr(178)=>333,chr(179)=>333,chr(180)=>333,chr(181)=>611,chr(182)=>556,chr(183)=>278,chr(184)=>333,chr(185)=>333,chr(186)=>365,chr(187)=>556,chr(188)=>834,chr(189)=>834,chr(190)=>834,chr(191)=>611,chr(192)=>722,chr(193)=>722,chr(194)=>722,chr(195)=>722,chr(196)=>722,chr(197)=>722,
|
||||
chr(198)=>1000,chr(199)=>722,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>278,chr(205)=>278,chr(206)=>278,chr(207)=>278,chr(208)=>722,chr(209)=>722,chr(210)=>778,chr(211)=>778,chr(212)=>778,chr(213)=>778,chr(214)=>778,chr(215)=>584,chr(216)=>778,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>667,chr(222)=>667,chr(223)=>611,chr(224)=>556,chr(225)=>556,chr(226)=>556,chr(227)=>556,chr(228)=>556,chr(229)=>556,chr(230)=>889,chr(231)=>556,chr(232)=>556,chr(233)=>556,chr(234)=>556,chr(235)=>556,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>611,chr(241)=>611,
|
||||
chr(242)=>611,chr(243)=>611,chr(244)=>611,chr(245)=>611,chr(246)=>611,chr(247)=>584,chr(248)=>611,chr(249)=>611,chr(250)=>611,chr(251)=>611,chr(252)=>611,chr(253)=>556,chr(254)=>611,chr(255)=>556);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helveticai.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/helveticai.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['helveticaI']=array(
|
||||
chr(0)=>278,chr(1)=>278,chr(2)=>278,chr(3)=>278,chr(4)=>278,chr(5)=>278,chr(6)=>278,chr(7)=>278,chr(8)=>278,chr(9)=>278,chr(10)=>278,chr(11)=>278,chr(12)=>278,chr(13)=>278,chr(14)=>278,chr(15)=>278,chr(16)=>278,chr(17)=>278,chr(18)=>278,chr(19)=>278,chr(20)=>278,chr(21)=>278,
|
||||
chr(22)=>278,chr(23)=>278,chr(24)=>278,chr(25)=>278,chr(26)=>278,chr(27)=>278,chr(28)=>278,chr(29)=>278,chr(30)=>278,chr(31)=>278,' '=>278,'!'=>278,'"'=>355,'#'=>556,'$'=>556,'%'=>889,'&'=>667,'\''=>191,'('=>333,')'=>333,'*'=>389,'+'=>584,
|
||||
','=>278,'-'=>333,'.'=>278,'/'=>278,'0'=>556,'1'=>556,'2'=>556,'3'=>556,'4'=>556,'5'=>556,'6'=>556,'7'=>556,'8'=>556,'9'=>556,':'=>278,';'=>278,'<'=>584,'='=>584,'>'=>584,'?'=>556,'@'=>1015,'A'=>667,
|
||||
'B'=>667,'C'=>722,'D'=>722,'E'=>667,'F'=>611,'G'=>778,'H'=>722,'I'=>278,'J'=>500,'K'=>667,'L'=>556,'M'=>833,'N'=>722,'O'=>778,'P'=>667,'Q'=>778,'R'=>722,'S'=>667,'T'=>611,'U'=>722,'V'=>667,'W'=>944,
|
||||
'X'=>667,'Y'=>667,'Z'=>611,'['=>278,'\\'=>278,']'=>278,'^'=>469,'_'=>556,'`'=>333,'a'=>556,'b'=>556,'c'=>500,'d'=>556,'e'=>556,'f'=>278,'g'=>556,'h'=>556,'i'=>222,'j'=>222,'k'=>500,'l'=>222,'m'=>833,
|
||||
'n'=>556,'o'=>556,'p'=>556,'q'=>556,'r'=>333,'s'=>500,'t'=>278,'u'=>556,'v'=>500,'w'=>722,'x'=>500,'y'=>500,'z'=>500,'{'=>334,'|'=>260,'}'=>334,'~'=>584,chr(127)=>350,chr(128)=>556,chr(129)=>350,chr(130)=>222,chr(131)=>556,
|
||||
chr(132)=>333,chr(133)=>1000,chr(134)=>556,chr(135)=>556,chr(136)=>333,chr(137)=>1000,chr(138)=>667,chr(139)=>333,chr(140)=>1000,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>222,chr(146)=>222,chr(147)=>333,chr(148)=>333,chr(149)=>350,chr(150)=>556,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
|
||||
chr(154)=>500,chr(155)=>333,chr(156)=>944,chr(157)=>350,chr(158)=>500,chr(159)=>667,chr(160)=>278,chr(161)=>333,chr(162)=>556,chr(163)=>556,chr(164)=>556,chr(165)=>556,chr(166)=>260,chr(167)=>556,chr(168)=>333,chr(169)=>737,chr(170)=>370,chr(171)=>556,chr(172)=>584,chr(173)=>333,chr(174)=>737,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>584,chr(178)=>333,chr(179)=>333,chr(180)=>333,chr(181)=>556,chr(182)=>537,chr(183)=>278,chr(184)=>333,chr(185)=>333,chr(186)=>365,chr(187)=>556,chr(188)=>834,chr(189)=>834,chr(190)=>834,chr(191)=>611,chr(192)=>667,chr(193)=>667,chr(194)=>667,chr(195)=>667,chr(196)=>667,chr(197)=>667,
|
||||
chr(198)=>1000,chr(199)=>722,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>278,chr(205)=>278,chr(206)=>278,chr(207)=>278,chr(208)=>722,chr(209)=>722,chr(210)=>778,chr(211)=>778,chr(212)=>778,chr(213)=>778,chr(214)=>778,chr(215)=>584,chr(216)=>778,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>667,chr(222)=>667,chr(223)=>611,chr(224)=>556,chr(225)=>556,chr(226)=>556,chr(227)=>556,chr(228)=>556,chr(229)=>556,chr(230)=>889,chr(231)=>500,chr(232)=>556,chr(233)=>556,chr(234)=>556,chr(235)=>556,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>556,chr(241)=>556,
|
||||
chr(242)=>556,chr(243)=>556,chr(244)=>556,chr(245)=>556,chr(246)=>556,chr(247)=>584,chr(248)=>611,chr(249)=>556,chr(250)=>556,chr(251)=>556,chr(252)=>556,chr(253)=>500,chr(254)=>556,chr(255)=>500);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/symbol.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/symbol.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['symbol']=array(
|
||||
chr(0)=>250,chr(1)=>250,chr(2)=>250,chr(3)=>250,chr(4)=>250,chr(5)=>250,chr(6)=>250,chr(7)=>250,chr(8)=>250,chr(9)=>250,chr(10)=>250,chr(11)=>250,chr(12)=>250,chr(13)=>250,chr(14)=>250,chr(15)=>250,chr(16)=>250,chr(17)=>250,chr(18)=>250,chr(19)=>250,chr(20)=>250,chr(21)=>250,
|
||||
chr(22)=>250,chr(23)=>250,chr(24)=>250,chr(25)=>250,chr(26)=>250,chr(27)=>250,chr(28)=>250,chr(29)=>250,chr(30)=>250,chr(31)=>250,' '=>250,'!'=>333,'"'=>713,'#'=>500,'$'=>549,'%'=>833,'&'=>778,'\''=>439,'('=>333,')'=>333,'*'=>500,'+'=>549,
|
||||
','=>250,'-'=>549,'.'=>250,'/'=>278,'0'=>500,'1'=>500,'2'=>500,'3'=>500,'4'=>500,'5'=>500,'6'=>500,'7'=>500,'8'=>500,'9'=>500,':'=>278,';'=>278,'<'=>549,'='=>549,'>'=>549,'?'=>444,'@'=>549,'A'=>722,
|
||||
'B'=>667,'C'=>722,'D'=>612,'E'=>611,'F'=>763,'G'=>603,'H'=>722,'I'=>333,'J'=>631,'K'=>722,'L'=>686,'M'=>889,'N'=>722,'O'=>722,'P'=>768,'Q'=>741,'R'=>556,'S'=>592,'T'=>611,'U'=>690,'V'=>439,'W'=>768,
|
||||
'X'=>645,'Y'=>795,'Z'=>611,'['=>333,'\\'=>863,']'=>333,'^'=>658,'_'=>500,'`'=>500,'a'=>631,'b'=>549,'c'=>549,'d'=>494,'e'=>439,'f'=>521,'g'=>411,'h'=>603,'i'=>329,'j'=>603,'k'=>549,'l'=>549,'m'=>576,
|
||||
'n'=>521,'o'=>549,'p'=>549,'q'=>521,'r'=>549,'s'=>603,'t'=>439,'u'=>576,'v'=>713,'w'=>686,'x'=>493,'y'=>686,'z'=>494,'{'=>480,'|'=>200,'}'=>480,'~'=>549,chr(127)=>0,chr(128)=>0,chr(129)=>0,chr(130)=>0,chr(131)=>0,
|
||||
chr(132)=>0,chr(133)=>0,chr(134)=>0,chr(135)=>0,chr(136)=>0,chr(137)=>0,chr(138)=>0,chr(139)=>0,chr(140)=>0,chr(141)=>0,chr(142)=>0,chr(143)=>0,chr(144)=>0,chr(145)=>0,chr(146)=>0,chr(147)=>0,chr(148)=>0,chr(149)=>0,chr(150)=>0,chr(151)=>0,chr(152)=>0,chr(153)=>0,
|
||||
chr(154)=>0,chr(155)=>0,chr(156)=>0,chr(157)=>0,chr(158)=>0,chr(159)=>0,chr(160)=>750,chr(161)=>620,chr(162)=>247,chr(163)=>549,chr(164)=>167,chr(165)=>713,chr(166)=>500,chr(167)=>753,chr(168)=>753,chr(169)=>753,chr(170)=>753,chr(171)=>1042,chr(172)=>987,chr(173)=>603,chr(174)=>987,chr(175)=>603,
|
||||
chr(176)=>400,chr(177)=>549,chr(178)=>411,chr(179)=>549,chr(180)=>549,chr(181)=>713,chr(182)=>494,chr(183)=>460,chr(184)=>549,chr(185)=>549,chr(186)=>549,chr(187)=>549,chr(188)=>1000,chr(189)=>603,chr(190)=>1000,chr(191)=>658,chr(192)=>823,chr(193)=>686,chr(194)=>795,chr(195)=>987,chr(196)=>768,chr(197)=>768,
|
||||
chr(198)=>823,chr(199)=>768,chr(200)=>768,chr(201)=>713,chr(202)=>713,chr(203)=>713,chr(204)=>713,chr(205)=>713,chr(206)=>713,chr(207)=>713,chr(208)=>768,chr(209)=>713,chr(210)=>790,chr(211)=>790,chr(212)=>890,chr(213)=>823,chr(214)=>549,chr(215)=>250,chr(216)=>713,chr(217)=>603,chr(218)=>603,chr(219)=>1042,
|
||||
chr(220)=>987,chr(221)=>603,chr(222)=>987,chr(223)=>603,chr(224)=>494,chr(225)=>329,chr(226)=>790,chr(227)=>790,chr(228)=>786,chr(229)=>713,chr(230)=>384,chr(231)=>384,chr(232)=>384,chr(233)=>384,chr(234)=>384,chr(235)=>384,chr(236)=>494,chr(237)=>494,chr(238)=>494,chr(239)=>494,chr(240)=>0,chr(241)=>329,
|
||||
chr(242)=>274,chr(243)=>686,chr(244)=>686,chr(245)=>686,chr(246)=>384,chr(247)=>384,chr(248)=>384,chr(249)=>384,chr(250)=>384,chr(251)=>384,chr(252)=>494,chr(253)=>494,chr(254)=>494,chr(255)=>0);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/times.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/times.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['times']=array(
|
||||
chr(0)=>250,chr(1)=>250,chr(2)=>250,chr(3)=>250,chr(4)=>250,chr(5)=>250,chr(6)=>250,chr(7)=>250,chr(8)=>250,chr(9)=>250,chr(10)=>250,chr(11)=>250,chr(12)=>250,chr(13)=>250,chr(14)=>250,chr(15)=>250,chr(16)=>250,chr(17)=>250,chr(18)=>250,chr(19)=>250,chr(20)=>250,chr(21)=>250,
|
||||
chr(22)=>250,chr(23)=>250,chr(24)=>250,chr(25)=>250,chr(26)=>250,chr(27)=>250,chr(28)=>250,chr(29)=>250,chr(30)=>250,chr(31)=>250,' '=>250,'!'=>333,'"'=>408,'#'=>500,'$'=>500,'%'=>833,'&'=>778,'\''=>180,'('=>333,')'=>333,'*'=>500,'+'=>564,
|
||||
','=>250,'-'=>333,'.'=>250,'/'=>278,'0'=>500,'1'=>500,'2'=>500,'3'=>500,'4'=>500,'5'=>500,'6'=>500,'7'=>500,'8'=>500,'9'=>500,':'=>278,';'=>278,'<'=>564,'='=>564,'>'=>564,'?'=>444,'@'=>921,'A'=>722,
|
||||
'B'=>667,'C'=>667,'D'=>722,'E'=>611,'F'=>556,'G'=>722,'H'=>722,'I'=>333,'J'=>389,'K'=>722,'L'=>611,'M'=>889,'N'=>722,'O'=>722,'P'=>556,'Q'=>722,'R'=>667,'S'=>556,'T'=>611,'U'=>722,'V'=>722,'W'=>944,
|
||||
'X'=>722,'Y'=>722,'Z'=>611,'['=>333,'\\'=>278,']'=>333,'^'=>469,'_'=>500,'`'=>333,'a'=>444,'b'=>500,'c'=>444,'d'=>500,'e'=>444,'f'=>333,'g'=>500,'h'=>500,'i'=>278,'j'=>278,'k'=>500,'l'=>278,'m'=>778,
|
||||
'n'=>500,'o'=>500,'p'=>500,'q'=>500,'r'=>333,'s'=>389,'t'=>278,'u'=>500,'v'=>500,'w'=>722,'x'=>500,'y'=>500,'z'=>444,'{'=>480,'|'=>200,'}'=>480,'~'=>541,chr(127)=>350,chr(128)=>500,chr(129)=>350,chr(130)=>333,chr(131)=>500,
|
||||
chr(132)=>444,chr(133)=>1000,chr(134)=>500,chr(135)=>500,chr(136)=>333,chr(137)=>1000,chr(138)=>556,chr(139)=>333,chr(140)=>889,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>333,chr(146)=>333,chr(147)=>444,chr(148)=>444,chr(149)=>350,chr(150)=>500,chr(151)=>1000,chr(152)=>333,chr(153)=>980,
|
||||
chr(154)=>389,chr(155)=>333,chr(156)=>722,chr(157)=>350,chr(158)=>444,chr(159)=>722,chr(160)=>250,chr(161)=>333,chr(162)=>500,chr(163)=>500,chr(164)=>500,chr(165)=>500,chr(166)=>200,chr(167)=>500,chr(168)=>333,chr(169)=>760,chr(170)=>276,chr(171)=>500,chr(172)=>564,chr(173)=>333,chr(174)=>760,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>564,chr(178)=>300,chr(179)=>300,chr(180)=>333,chr(181)=>500,chr(182)=>453,chr(183)=>250,chr(184)=>333,chr(185)=>300,chr(186)=>310,chr(187)=>500,chr(188)=>750,chr(189)=>750,chr(190)=>750,chr(191)=>444,chr(192)=>722,chr(193)=>722,chr(194)=>722,chr(195)=>722,chr(196)=>722,chr(197)=>722,
|
||||
chr(198)=>889,chr(199)=>667,chr(200)=>611,chr(201)=>611,chr(202)=>611,chr(203)=>611,chr(204)=>333,chr(205)=>333,chr(206)=>333,chr(207)=>333,chr(208)=>722,chr(209)=>722,chr(210)=>722,chr(211)=>722,chr(212)=>722,chr(213)=>722,chr(214)=>722,chr(215)=>564,chr(216)=>722,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>722,chr(222)=>556,chr(223)=>500,chr(224)=>444,chr(225)=>444,chr(226)=>444,chr(227)=>444,chr(228)=>444,chr(229)=>444,chr(230)=>667,chr(231)=>444,chr(232)=>444,chr(233)=>444,chr(234)=>444,chr(235)=>444,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>500,chr(241)=>500,
|
||||
chr(242)=>500,chr(243)=>500,chr(244)=>500,chr(245)=>500,chr(246)=>500,chr(247)=>564,chr(248)=>500,chr(249)=>500,chr(250)=>500,chr(251)=>500,chr(252)=>500,chr(253)=>500,chr(254)=>500,chr(255)=>500);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/timesb.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/timesb.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['timesB']=array(
|
||||
chr(0)=>250,chr(1)=>250,chr(2)=>250,chr(3)=>250,chr(4)=>250,chr(5)=>250,chr(6)=>250,chr(7)=>250,chr(8)=>250,chr(9)=>250,chr(10)=>250,chr(11)=>250,chr(12)=>250,chr(13)=>250,chr(14)=>250,chr(15)=>250,chr(16)=>250,chr(17)=>250,chr(18)=>250,chr(19)=>250,chr(20)=>250,chr(21)=>250,
|
||||
chr(22)=>250,chr(23)=>250,chr(24)=>250,chr(25)=>250,chr(26)=>250,chr(27)=>250,chr(28)=>250,chr(29)=>250,chr(30)=>250,chr(31)=>250,' '=>250,'!'=>333,'"'=>555,'#'=>500,'$'=>500,'%'=>1000,'&'=>833,'\''=>278,'('=>333,')'=>333,'*'=>500,'+'=>570,
|
||||
','=>250,'-'=>333,'.'=>250,'/'=>278,'0'=>500,'1'=>500,'2'=>500,'3'=>500,'4'=>500,'5'=>500,'6'=>500,'7'=>500,'8'=>500,'9'=>500,':'=>333,';'=>333,'<'=>570,'='=>570,'>'=>570,'?'=>500,'@'=>930,'A'=>722,
|
||||
'B'=>667,'C'=>722,'D'=>722,'E'=>667,'F'=>611,'G'=>778,'H'=>778,'I'=>389,'J'=>500,'K'=>778,'L'=>667,'M'=>944,'N'=>722,'O'=>778,'P'=>611,'Q'=>778,'R'=>722,'S'=>556,'T'=>667,'U'=>722,'V'=>722,'W'=>1000,
|
||||
'X'=>722,'Y'=>722,'Z'=>667,'['=>333,'\\'=>278,']'=>333,'^'=>581,'_'=>500,'`'=>333,'a'=>500,'b'=>556,'c'=>444,'d'=>556,'e'=>444,'f'=>333,'g'=>500,'h'=>556,'i'=>278,'j'=>333,'k'=>556,'l'=>278,'m'=>833,
|
||||
'n'=>556,'o'=>500,'p'=>556,'q'=>556,'r'=>444,'s'=>389,'t'=>333,'u'=>556,'v'=>500,'w'=>722,'x'=>500,'y'=>500,'z'=>444,'{'=>394,'|'=>220,'}'=>394,'~'=>520,chr(127)=>350,chr(128)=>500,chr(129)=>350,chr(130)=>333,chr(131)=>500,
|
||||
chr(132)=>500,chr(133)=>1000,chr(134)=>500,chr(135)=>500,chr(136)=>333,chr(137)=>1000,chr(138)=>556,chr(139)=>333,chr(140)=>1000,chr(141)=>350,chr(142)=>667,chr(143)=>350,chr(144)=>350,chr(145)=>333,chr(146)=>333,chr(147)=>500,chr(148)=>500,chr(149)=>350,chr(150)=>500,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
|
||||
chr(154)=>389,chr(155)=>333,chr(156)=>722,chr(157)=>350,chr(158)=>444,chr(159)=>722,chr(160)=>250,chr(161)=>333,chr(162)=>500,chr(163)=>500,chr(164)=>500,chr(165)=>500,chr(166)=>220,chr(167)=>500,chr(168)=>333,chr(169)=>747,chr(170)=>300,chr(171)=>500,chr(172)=>570,chr(173)=>333,chr(174)=>747,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>570,chr(178)=>300,chr(179)=>300,chr(180)=>333,chr(181)=>556,chr(182)=>540,chr(183)=>250,chr(184)=>333,chr(185)=>300,chr(186)=>330,chr(187)=>500,chr(188)=>750,chr(189)=>750,chr(190)=>750,chr(191)=>500,chr(192)=>722,chr(193)=>722,chr(194)=>722,chr(195)=>722,chr(196)=>722,chr(197)=>722,
|
||||
chr(198)=>1000,chr(199)=>722,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>389,chr(205)=>389,chr(206)=>389,chr(207)=>389,chr(208)=>722,chr(209)=>722,chr(210)=>778,chr(211)=>778,chr(212)=>778,chr(213)=>778,chr(214)=>778,chr(215)=>570,chr(216)=>778,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>722,chr(222)=>611,chr(223)=>556,chr(224)=>500,chr(225)=>500,chr(226)=>500,chr(227)=>500,chr(228)=>500,chr(229)=>500,chr(230)=>722,chr(231)=>444,chr(232)=>444,chr(233)=>444,chr(234)=>444,chr(235)=>444,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>500,chr(241)=>556,
|
||||
chr(242)=>500,chr(243)=>500,chr(244)=>500,chr(245)=>500,chr(246)=>500,chr(247)=>570,chr(248)=>500,chr(249)=>556,chr(250)=>556,chr(251)=>556,chr(252)=>556,chr(253)=>500,chr(254)=>556,chr(255)=>500);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/timesbi.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/timesbi.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['timesBI']=array(
|
||||
chr(0)=>250,chr(1)=>250,chr(2)=>250,chr(3)=>250,chr(4)=>250,chr(5)=>250,chr(6)=>250,chr(7)=>250,chr(8)=>250,chr(9)=>250,chr(10)=>250,chr(11)=>250,chr(12)=>250,chr(13)=>250,chr(14)=>250,chr(15)=>250,chr(16)=>250,chr(17)=>250,chr(18)=>250,chr(19)=>250,chr(20)=>250,chr(21)=>250,
|
||||
chr(22)=>250,chr(23)=>250,chr(24)=>250,chr(25)=>250,chr(26)=>250,chr(27)=>250,chr(28)=>250,chr(29)=>250,chr(30)=>250,chr(31)=>250,' '=>250,'!'=>389,'"'=>555,'#'=>500,'$'=>500,'%'=>833,'&'=>778,'\''=>278,'('=>333,')'=>333,'*'=>500,'+'=>570,
|
||||
','=>250,'-'=>333,'.'=>250,'/'=>278,'0'=>500,'1'=>500,'2'=>500,'3'=>500,'4'=>500,'5'=>500,'6'=>500,'7'=>500,'8'=>500,'9'=>500,':'=>333,';'=>333,'<'=>570,'='=>570,'>'=>570,'?'=>500,'@'=>832,'A'=>667,
|
||||
'B'=>667,'C'=>667,'D'=>722,'E'=>667,'F'=>667,'G'=>722,'H'=>778,'I'=>389,'J'=>500,'K'=>667,'L'=>611,'M'=>889,'N'=>722,'O'=>722,'P'=>611,'Q'=>722,'R'=>667,'S'=>556,'T'=>611,'U'=>722,'V'=>667,'W'=>889,
|
||||
'X'=>667,'Y'=>611,'Z'=>611,'['=>333,'\\'=>278,']'=>333,'^'=>570,'_'=>500,'`'=>333,'a'=>500,'b'=>500,'c'=>444,'d'=>500,'e'=>444,'f'=>333,'g'=>500,'h'=>556,'i'=>278,'j'=>278,'k'=>500,'l'=>278,'m'=>778,
|
||||
'n'=>556,'o'=>500,'p'=>500,'q'=>500,'r'=>389,'s'=>389,'t'=>278,'u'=>556,'v'=>444,'w'=>667,'x'=>500,'y'=>444,'z'=>389,'{'=>348,'|'=>220,'}'=>348,'~'=>570,chr(127)=>350,chr(128)=>500,chr(129)=>350,chr(130)=>333,chr(131)=>500,
|
||||
chr(132)=>500,chr(133)=>1000,chr(134)=>500,chr(135)=>500,chr(136)=>333,chr(137)=>1000,chr(138)=>556,chr(139)=>333,chr(140)=>944,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>333,chr(146)=>333,chr(147)=>500,chr(148)=>500,chr(149)=>350,chr(150)=>500,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
|
||||
chr(154)=>389,chr(155)=>333,chr(156)=>722,chr(157)=>350,chr(158)=>389,chr(159)=>611,chr(160)=>250,chr(161)=>389,chr(162)=>500,chr(163)=>500,chr(164)=>500,chr(165)=>500,chr(166)=>220,chr(167)=>500,chr(168)=>333,chr(169)=>747,chr(170)=>266,chr(171)=>500,chr(172)=>606,chr(173)=>333,chr(174)=>747,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>570,chr(178)=>300,chr(179)=>300,chr(180)=>333,chr(181)=>576,chr(182)=>500,chr(183)=>250,chr(184)=>333,chr(185)=>300,chr(186)=>300,chr(187)=>500,chr(188)=>750,chr(189)=>750,chr(190)=>750,chr(191)=>500,chr(192)=>667,chr(193)=>667,chr(194)=>667,chr(195)=>667,chr(196)=>667,chr(197)=>667,
|
||||
chr(198)=>944,chr(199)=>667,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>389,chr(205)=>389,chr(206)=>389,chr(207)=>389,chr(208)=>722,chr(209)=>722,chr(210)=>722,chr(211)=>722,chr(212)=>722,chr(213)=>722,chr(214)=>722,chr(215)=>570,chr(216)=>722,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>611,chr(222)=>611,chr(223)=>500,chr(224)=>500,chr(225)=>500,chr(226)=>500,chr(227)=>500,chr(228)=>500,chr(229)=>500,chr(230)=>722,chr(231)=>444,chr(232)=>444,chr(233)=>444,chr(234)=>444,chr(235)=>444,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>500,chr(241)=>556,
|
||||
chr(242)=>500,chr(243)=>500,chr(244)=>500,chr(245)=>500,chr(246)=>500,chr(247)=>570,chr(248)=>500,chr(249)=>556,chr(250)=>556,chr(251)=>556,chr(252)=>556,chr(253)=>444,chr(254)=>500,chr(255)=>444);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/timesi.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/timesi.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['timesI']=array(
|
||||
chr(0)=>250,chr(1)=>250,chr(2)=>250,chr(3)=>250,chr(4)=>250,chr(5)=>250,chr(6)=>250,chr(7)=>250,chr(8)=>250,chr(9)=>250,chr(10)=>250,chr(11)=>250,chr(12)=>250,chr(13)=>250,chr(14)=>250,chr(15)=>250,chr(16)=>250,chr(17)=>250,chr(18)=>250,chr(19)=>250,chr(20)=>250,chr(21)=>250,
|
||||
chr(22)=>250,chr(23)=>250,chr(24)=>250,chr(25)=>250,chr(26)=>250,chr(27)=>250,chr(28)=>250,chr(29)=>250,chr(30)=>250,chr(31)=>250,' '=>250,'!'=>333,'"'=>420,'#'=>500,'$'=>500,'%'=>833,'&'=>778,'\''=>214,'('=>333,')'=>333,'*'=>500,'+'=>675,
|
||||
','=>250,'-'=>333,'.'=>250,'/'=>278,'0'=>500,'1'=>500,'2'=>500,'3'=>500,'4'=>500,'5'=>500,'6'=>500,'7'=>500,'8'=>500,'9'=>500,':'=>333,';'=>333,'<'=>675,'='=>675,'>'=>675,'?'=>500,'@'=>920,'A'=>611,
|
||||
'B'=>611,'C'=>667,'D'=>722,'E'=>611,'F'=>611,'G'=>722,'H'=>722,'I'=>333,'J'=>444,'K'=>667,'L'=>556,'M'=>833,'N'=>667,'O'=>722,'P'=>611,'Q'=>722,'R'=>611,'S'=>500,'T'=>556,'U'=>722,'V'=>611,'W'=>833,
|
||||
'X'=>611,'Y'=>556,'Z'=>556,'['=>389,'\\'=>278,']'=>389,'^'=>422,'_'=>500,'`'=>333,'a'=>500,'b'=>500,'c'=>444,'d'=>500,'e'=>444,'f'=>278,'g'=>500,'h'=>500,'i'=>278,'j'=>278,'k'=>444,'l'=>278,'m'=>722,
|
||||
'n'=>500,'o'=>500,'p'=>500,'q'=>500,'r'=>389,'s'=>389,'t'=>278,'u'=>500,'v'=>444,'w'=>667,'x'=>444,'y'=>444,'z'=>389,'{'=>400,'|'=>275,'}'=>400,'~'=>541,chr(127)=>350,chr(128)=>500,chr(129)=>350,chr(130)=>333,chr(131)=>500,
|
||||
chr(132)=>556,chr(133)=>889,chr(134)=>500,chr(135)=>500,chr(136)=>333,chr(137)=>1000,chr(138)=>500,chr(139)=>333,chr(140)=>944,chr(141)=>350,chr(142)=>556,chr(143)=>350,chr(144)=>350,chr(145)=>333,chr(146)=>333,chr(147)=>556,chr(148)=>556,chr(149)=>350,chr(150)=>500,chr(151)=>889,chr(152)=>333,chr(153)=>980,
|
||||
chr(154)=>389,chr(155)=>333,chr(156)=>667,chr(157)=>350,chr(158)=>389,chr(159)=>556,chr(160)=>250,chr(161)=>389,chr(162)=>500,chr(163)=>500,chr(164)=>500,chr(165)=>500,chr(166)=>275,chr(167)=>500,chr(168)=>333,chr(169)=>760,chr(170)=>276,chr(171)=>500,chr(172)=>675,chr(173)=>333,chr(174)=>760,chr(175)=>333,
|
||||
chr(176)=>400,chr(177)=>675,chr(178)=>300,chr(179)=>300,chr(180)=>333,chr(181)=>500,chr(182)=>523,chr(183)=>250,chr(184)=>333,chr(185)=>300,chr(186)=>310,chr(187)=>500,chr(188)=>750,chr(189)=>750,chr(190)=>750,chr(191)=>500,chr(192)=>611,chr(193)=>611,chr(194)=>611,chr(195)=>611,chr(196)=>611,chr(197)=>611,
|
||||
chr(198)=>889,chr(199)=>667,chr(200)=>611,chr(201)=>611,chr(202)=>611,chr(203)=>611,chr(204)=>333,chr(205)=>333,chr(206)=>333,chr(207)=>333,chr(208)=>722,chr(209)=>667,chr(210)=>722,chr(211)=>722,chr(212)=>722,chr(213)=>722,chr(214)=>722,chr(215)=>675,chr(216)=>722,chr(217)=>722,chr(218)=>722,chr(219)=>722,
|
||||
chr(220)=>722,chr(221)=>556,chr(222)=>611,chr(223)=>500,chr(224)=>500,chr(225)=>500,chr(226)=>500,chr(227)=>500,chr(228)=>500,chr(229)=>500,chr(230)=>667,chr(231)=>444,chr(232)=>444,chr(233)=>444,chr(234)=>444,chr(235)=>444,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>500,chr(241)=>500,
|
||||
chr(242)=>500,chr(243)=>500,chr(244)=>500,chr(245)=>500,chr(246)=>500,chr(247)=>675,chr(248)=>500,chr(249)=>500,chr(250)=>500,chr(251)=>500,chr(252)=>500,chr(253)=>444,chr(254)=>500,chr(255)=>444);
|
||||
?>
|
||||
15
include/PHPExcel/PHPExcel/Shared/PDF/font/zapfdingbats.php
Executable file
15
include/PHPExcel/PHPExcel/Shared/PDF/font/zapfdingbats.php
Executable file
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
$fpdf_charwidths['zapfdingbats']=array(
|
||||
chr(0)=>0,chr(1)=>0,chr(2)=>0,chr(3)=>0,chr(4)=>0,chr(5)=>0,chr(6)=>0,chr(7)=>0,chr(8)=>0,chr(9)=>0,chr(10)=>0,chr(11)=>0,chr(12)=>0,chr(13)=>0,chr(14)=>0,chr(15)=>0,chr(16)=>0,chr(17)=>0,chr(18)=>0,chr(19)=>0,chr(20)=>0,chr(21)=>0,
|
||||
chr(22)=>0,chr(23)=>0,chr(24)=>0,chr(25)=>0,chr(26)=>0,chr(27)=>0,chr(28)=>0,chr(29)=>0,chr(30)=>0,chr(31)=>0,' '=>278,'!'=>974,'"'=>961,'#'=>974,'$'=>980,'%'=>719,'&'=>789,'\''=>790,'('=>791,')'=>690,'*'=>960,'+'=>939,
|
||||
','=>549,'-'=>855,'.'=>911,'/'=>933,'0'=>911,'1'=>945,'2'=>974,'3'=>755,'4'=>846,'5'=>762,'6'=>761,'7'=>571,'8'=>677,'9'=>763,':'=>760,';'=>759,'<'=>754,'='=>494,'>'=>552,'?'=>537,'@'=>577,'A'=>692,
|
||||
'B'=>786,'C'=>788,'D'=>788,'E'=>790,'F'=>793,'G'=>794,'H'=>816,'I'=>823,'J'=>789,'K'=>841,'L'=>823,'M'=>833,'N'=>816,'O'=>831,'P'=>923,'Q'=>744,'R'=>723,'S'=>749,'T'=>790,'U'=>792,'V'=>695,'W'=>776,
|
||||
'X'=>768,'Y'=>792,'Z'=>759,'['=>707,'\\'=>708,']'=>682,'^'=>701,'_'=>826,'`'=>815,'a'=>789,'b'=>789,'c'=>707,'d'=>687,'e'=>696,'f'=>689,'g'=>786,'h'=>787,'i'=>713,'j'=>791,'k'=>785,'l'=>791,'m'=>873,
|
||||
'n'=>761,'o'=>762,'p'=>762,'q'=>759,'r'=>759,'s'=>892,'t'=>892,'u'=>788,'v'=>784,'w'=>438,'x'=>138,'y'=>277,'z'=>415,'{'=>392,'|'=>392,'}'=>668,'~'=>668,chr(127)=>0,chr(128)=>390,chr(129)=>390,chr(130)=>317,chr(131)=>317,
|
||||
chr(132)=>276,chr(133)=>276,chr(134)=>509,chr(135)=>509,chr(136)=>410,chr(137)=>410,chr(138)=>234,chr(139)=>234,chr(140)=>334,chr(141)=>334,chr(142)=>0,chr(143)=>0,chr(144)=>0,chr(145)=>0,chr(146)=>0,chr(147)=>0,chr(148)=>0,chr(149)=>0,chr(150)=>0,chr(151)=>0,chr(152)=>0,chr(153)=>0,
|
||||
chr(154)=>0,chr(155)=>0,chr(156)=>0,chr(157)=>0,chr(158)=>0,chr(159)=>0,chr(160)=>0,chr(161)=>732,chr(162)=>544,chr(163)=>544,chr(164)=>910,chr(165)=>667,chr(166)=>760,chr(167)=>760,chr(168)=>776,chr(169)=>595,chr(170)=>694,chr(171)=>626,chr(172)=>788,chr(173)=>788,chr(174)=>788,chr(175)=>788,
|
||||
chr(176)=>788,chr(177)=>788,chr(178)=>788,chr(179)=>788,chr(180)=>788,chr(181)=>788,chr(182)=>788,chr(183)=>788,chr(184)=>788,chr(185)=>788,chr(186)=>788,chr(187)=>788,chr(188)=>788,chr(189)=>788,chr(190)=>788,chr(191)=>788,chr(192)=>788,chr(193)=>788,chr(194)=>788,chr(195)=>788,chr(196)=>788,chr(197)=>788,
|
||||
chr(198)=>788,chr(199)=>788,chr(200)=>788,chr(201)=>788,chr(202)=>788,chr(203)=>788,chr(204)=>788,chr(205)=>788,chr(206)=>788,chr(207)=>788,chr(208)=>788,chr(209)=>788,chr(210)=>788,chr(211)=>788,chr(212)=>894,chr(213)=>838,chr(214)=>1016,chr(215)=>458,chr(216)=>748,chr(217)=>924,chr(218)=>748,chr(219)=>918,
|
||||
chr(220)=>927,chr(221)=>928,chr(222)=>928,chr(223)=>834,chr(224)=>873,chr(225)=>828,chr(226)=>924,chr(227)=>924,chr(228)=>917,chr(229)=>930,chr(230)=>931,chr(231)=>463,chr(232)=>883,chr(233)=>836,chr(234)=>836,chr(235)=>867,chr(236)=>867,chr(237)=>696,chr(238)=>696,chr(239)=>874,chr(240)=>0,chr(241)=>874,
|
||||
chr(242)=>760,chr(243)=>946,chr(244)=>771,chr(245)=>865,chr(246)=>771,chr(247)=>888,chr(248)=>967,chr(249)=>888,chr(250)=>831,chr(251)=>873,chr(252)=>927,chr(253)=>970,chr(254)=>918,chr(255)=>0);
|
||||
?>
|
||||
1768
include/PHPExcel/PHPExcel/Shared/PDF/fonts/arialunicid0.php
Executable file
1768
include/PHPExcel/PHPExcel/Shared/PDF/fonts/arialunicid0.php
Executable file
File diff suppressed because it is too large
Load Diff
33
include/PHPExcel/PHPExcel/Shared/PDF/fonts/courier.php
Executable file
33
include/PHPExcel/PHPExcel/Shared/PDF/fonts/courier.php
Executable file
@@ -0,0 +1,33 @@
|
||||
<?php
|
||||
// core font definition file for TCPDF (www.tcpdf.org)
|
||||
$type='core';
|
||||
$dw=600;
|
||||
$cw=array(0=>600,1=>600,2=>600,3=>600,4=>600,5=>600,6=>600,7=>600,8=>600,9=>600,
|
||||
10=>600,11=>600,12=>600,13=>600,14=>600,15=>600,16=>600,17=>600,18=>600,19=>600,
|
||||
20=>600,21=>600,22=>600,23=>600,24=>600,25=>600,26=>600,27=>600,28=>600,29=>600,
|
||||
30=>600,31=>600,32=>600,33=>600,34=>600,35=>600,36=>600,37=>600,38=>600,39=>600,
|
||||
40=>600,41=>600,42=>600,43=>600,44=>600,45=>600,46=>600,47=>600,48=>600,49=>600,
|
||||
50=>600,51=>600,52=>600,53=>600,54=>600,55=>600,56=>600,57=>600,58=>600,59=>600,
|
||||
60=>600,61=>600,62=>600,63=>600,64=>600,65=>600,66=>600,67=>600,68=>600,69=>600,
|
||||
70=>600,71=>600,72=>600,73=>600,74=>600,75=>600,76=>600,77=>600,78=>600,79=>600,
|
||||
80=>600,81=>600,82=>600,83=>600,84=>600,85=>600,86=>600,87=>600,88=>600,89=>600,
|
||||
90=>600,91=>600,92=>600,93=>600,94=>600,95=>600,96=>600,97=>600,98=>600,99=>600,
|
||||
100=>600,101=>600,102=>600,103=>600,104=>600,105=>600,106=>600,107=>600,108=>600,
|
||||
109=>600,110=>600,111=>600,112=>600,113=>600,114=>600,115=>600,116=>600,117=>600,
|
||||
118=>600,119=>600,120=>600,121=>600,122=>600,123=>600,124=>600,125=>600,126=>600,
|
||||
127=>600,128=>600,129=>600,130=>600,131=>600,132=>600,133=>600,134=>600,135=>600,
|
||||
136=>600,137=>600,138=>600,139=>600,140=>600,141=>600,142=>600,143=>600,144=>600,
|
||||
145=>600,146=>600,147=>600,148=>600,149=>600,150=>600,151=>600,152=>600,153=>600,
|
||||
154=>600,155=>600,156=>600,157=>600,158=>600,159=>600,160=>600,161=>600,162=>600,
|
||||
163=>600,164=>600,165=>600,166=>600,167=>600,168=>600,169=>600,170=>600,171=>600,
|
||||
172=>600,173=>600,174=>600,175=>600,176=>600,177=>600,178=>600,179=>600,180=>600,
|
||||
181=>600,182=>600,183=>600,184=>600,185=>600,186=>600,187=>600,188=>600,189=>600,
|
||||
190=>600,191=>600,192=>600,193=>600,194=>600,195=>600,196=>600,197=>600,198=>600,
|
||||
199=>600,200=>600,201=>600,202=>600,203=>600,204=>600,205=>600,206=>600,207=>600,
|
||||
208=>600,209=>600,210=>600,211=>600,212=>600,213=>600,214=>600,215=>600,216=>600,
|
||||
217=>600,218=>600,219=>600,220=>600,221=>600,222=>600,223=>600,224=>600,225=>600,
|
||||
226=>600,227=>600,228=>600,229=>600,230=>600,231=>600,232=>600,233=>600,234=>600,
|
||||
235=>600,236=>600,237=>600,238=>600,239=>600,240=>600,241=>600,242=>600,243=>600,
|
||||
244=>600,245=>600,246=>600,247=>600,248=>600,249=>600,250=>600,251=>600,252=>600,
|
||||
253=>600,254=>600,255=>600);
|
||||
?>
|
||||
33
include/PHPExcel/PHPExcel/Shared/PDF/fonts/helvetica.php
Executable file
33
include/PHPExcel/PHPExcel/Shared/PDF/fonts/helvetica.php
Executable file
@@ -0,0 +1,33 @@
|
||||
<?php
|
||||
// core font definition file for TCPDF (www.tcpdf.org)
|
||||
$type='core';
|
||||
$dw=556;
|
||||
$cw=array(0=>278,1=>278,2=>278,3=>278,4=>278,5=>278,6=>278,7=>278,8=>278,9=>278,
|
||||
10=>278,11=>278,12=>278,13=>278,14=>278,15=>278,16=>278,17=>278,18=>278,19=>278,
|
||||
20=>278,21=>278,22=>278,23=>278,24=>278,25=>278,26=>278,27=>278,28=>278,29=>278,
|
||||
30=>278,31=>278,32=>278,33=>278,34=>355,35=>556,36=>556,37=>889,38=>667,39=>191,
|
||||
40=>333,41=>333,42=>389,43=>584,44=>278,45=>333,46=>278,47=>278,48=>556,49=>556,
|
||||
50=>556,51=>556,52=>556,53=>556,54=>556,55=>556,56=>556,57=>556,58=>278,59=>278,
|
||||
60=>584,61=>584,62=>584,63=>556,64=>1015,65=>667,66=>667,67=>722,68=>722,69=>667,
|
||||
70=>611,71=>778,72=>722,73=>278,74=>500,75=>667,76=>556,77=>833,78=>722,79=>778,
|
||||
80=>667,81=>778,82=>722,83=>667,84=>611,85=>722,86=>667,87=>944,88=>667,89=>667,
|
||||
90=>611,91=>278,92=>278,93=>278,94=>469,95=>556,96=>333,97=>556,98=>556,99=>500,
|
||||
100=>556,101=>556,102=>278,103=>556,104=>556,105=>222,106=>222,107=>500,108=>222,
|
||||
109=>833,110=>556,111=>556,112=>556,113=>556,114=>333,115=>500,116=>278,117=>556,
|
||||
118=>500,119=>722,120=>500,121=>500,122=>500,123=>334,124=>260,125=>334,126=>584,
|
||||
127=>350,128=>556,129=>350,130=>222,131=>556,132=>333,133=>1000,134=>556,135=>556,
|
||||
136=>333,137=>1000,138=>667,139=>333,140=>1000,141=>350,142=>611,143=>350,144=>350,
|
||||
145=>222,146=>222,147=>333,148=>333,149=>350,150=>556,151=>1000,152=>333,153=>1000,
|
||||
154=>500,155=>333,156=>944,157=>350,158=>500,159=>667,160=>278,161=>333,162=>556,
|
||||
163=>556,164=>556,165=>556,166=>260,167=>556,168=>333,169=>737,170=>370,171=>556,
|
||||
172=>584,173=>333,174=>737,175=>333,176=>400,177=>584,178=>333,179=>333,180=>333,
|
||||
181=>556,182=>537,183=>278,184=>333,185=>333,186=>365,187=>556,188=>834,189=>834,
|
||||
190=>834,191=>611,192=>667,193=>667,194=>667,195=>667,196=>667,197=>667,198=>1000,
|
||||
199=>722,200=>667,201=>667,202=>667,203=>667,204=>278,205=>278,206=>278,207=>278,
|
||||
208=>722,209=>722,210=>778,211=>778,212=>778,213=>778,214=>778,215=>584,216=>778,
|
||||
217=>722,218=>722,219=>722,220=>722,221=>667,222=>667,223=>611,224=>556,225=>556,
|
||||
226=>556,227=>556,228=>556,229=>556,230=>889,231=>500,232=>556,233=>556,234=>556,
|
||||
235=>556,236=>278,237=>278,238=>278,239=>278,240=>556,241=>556,242=>556,243=>556,
|
||||
244=>556,245=>556,246=>556,247=>584,248=>611,249=>556,250=>556,251=>556,252=>556,
|
||||
253=>500,254=>556,255=>500);
|
||||
?>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user