| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/NumberFormat.php |
|---|
| New file |
| 0,0 → 1,708 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_NumberFormat |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_NumberFormat extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Pre-defined formats */ |
| const FORMAT_GENERAL = 'General'; |
| const FORMAT_TEXT = '@'; |
| const FORMAT_NUMBER = '0'; |
| const FORMAT_NUMBER_00 = '0.00'; |
| const FORMAT_NUMBER_COMMA_SEPARATED1 = '#,##0.00'; |
| const FORMAT_NUMBER_COMMA_SEPARATED2 = '#,##0.00_-'; |
| const FORMAT_PERCENTAGE = '0%'; |
| const FORMAT_PERCENTAGE_00 = '0.00%'; |
| const FORMAT_DATE_YYYYMMDD2 = 'yyyy-mm-dd'; |
| const FORMAT_DATE_YYYYMMDD = 'yy-mm-dd'; |
| const FORMAT_DATE_DDMMYYYY = 'dd/mm/yy'; |
| const FORMAT_DATE_DMYSLASH = 'd/m/y'; |
| const FORMAT_DATE_DMYMINUS = 'd-m-y'; |
| const FORMAT_DATE_DMMINUS = 'd-m'; |
| const FORMAT_DATE_MYMINUS = 'm-y'; |
| const FORMAT_DATE_XLSX14 = 'mm-dd-yy'; |
| const FORMAT_DATE_XLSX15 = 'd-mmm-yy'; |
| const FORMAT_DATE_XLSX16 = 'd-mmm'; |
| const FORMAT_DATE_XLSX17 = 'mmm-yy'; |
| const FORMAT_DATE_XLSX22 = 'm/d/yy h:mm'; |
| const FORMAT_DATE_DATETIME = 'd/m/y h:mm'; |
| const FORMAT_DATE_TIME1 = 'h:mm AM/PM'; |
| const FORMAT_DATE_TIME2 = 'h:mm:ss AM/PM'; |
| const FORMAT_DATE_TIME3 = 'h:mm'; |
| const FORMAT_DATE_TIME4 = 'h:mm:ss'; |
| const FORMAT_DATE_TIME5 = 'mm:ss'; |
| const FORMAT_DATE_TIME6 = 'h:mm:ss'; |
| const FORMAT_DATE_TIME7 = 'i:s.S'; |
| const FORMAT_DATE_TIME8 = 'h:mm:ss;@'; |
| const FORMAT_DATE_YYYYMMDDSLASH = 'yy/mm/dd;@'; |
| const FORMAT_CURRENCY_USD_SIMPLE = '"$"#,##0.00_-'; |
| const FORMAT_CURRENCY_USD = '$#,##0_-'; |
| const FORMAT_CURRENCY_EUR_SIMPLE = '[$EUR ]#,##0.00_-'; |
| /** |
| * Excel built-in number formats |
| * |
| * @var array |
| */ |
| protected static $_builtInFormats; |
| /** |
| * Excel built-in number formats (flipped, for faster lookups) |
| * |
| * @var array |
| */ |
| protected static $_flippedBuiltInFormats; |
| /** |
| * Format Code |
| * |
| * @var string |
| */ |
| protected $_formatCode = PHPExcel_Style_NumberFormat::FORMAT_GENERAL; |
| /** |
| * Built-in format Code |
| * |
| * @var string |
| */ |
| protected $_builtInFormatCode = 0; |
| /** |
| * Create a new PHPExcel_Style_NumberFormat |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| if ($isConditional) { |
| $this->_formatCode = NULL; |
| } |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_NumberFormat |
| */ |
| public function getSharedComponent() |
| { |
| return $this->_parent->getSharedComponent()->getNumberFormat(); |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| return array('numberformat' => $array); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getNumberFormat()->applyFromArray( |
| * array( |
| * 'code' => PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_EUR_SIMPLE |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_NumberFormat |
| */ |
| public function applyFromArray($pStyles = null) |
| { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (array_key_exists('code', $pStyles)) { |
| $this->setFormatCode($pStyles['code']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get Format Code |
| * |
| * @return string |
| */ |
| public function getFormatCode() |
| { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getFormatCode(); |
| } |
| if ($this->_builtInFormatCode !== false) |
| { |
| return self::builtInFormatCode($this->_builtInFormatCode); |
| } |
| return $this->_formatCode; |
| } |
| /** |
| * Set Format Code |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_NumberFormat |
| */ |
| public function setFormatCode($pValue = PHPExcel_Style_NumberFormat::FORMAT_GENERAL) |
| { |
| if ($pValue == '') { |
| $pValue = PHPExcel_Style_NumberFormat::FORMAT_GENERAL; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('code' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_formatCode = $pValue; |
| $this->_builtInFormatCode = self::builtInFormatCodeIndex($pValue); |
| } |
| return $this; |
| } |
| /** |
| * Get Built-In Format Code |
| * |
| * @return int |
| */ |
| public function getBuiltInFormatCode() |
| { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getBuiltInFormatCode(); |
| } |
| return $this->_builtInFormatCode; |
| } |
| /** |
| * Set Built-In Format Code |
| * |
| * @param int $pValue |
| * @return PHPExcel_Style_NumberFormat |
| */ |
| public function setBuiltInFormatCode($pValue = 0) |
| { |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('code' => self::builtInFormatCode($pValue))); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_builtInFormatCode = $pValue; |
| $this->_formatCode = self::builtInFormatCode($pValue); |
| } |
| return $this; |
| } |
| /** |
| * Fill built-in format codes |
| */ |
| private static function fillBuiltInFormatCodes() |
| { |
| // Built-in format codes |
| if (is_null(self::$_builtInFormats)) { |
| self::$_builtInFormats = array(); |
| // General |
| self::$_builtInFormats[0] = PHPExcel_Style_NumberFormat::FORMAT_GENERAL; |
| self::$_builtInFormats[1] = '0'; |
| self::$_builtInFormats[2] = '0.00'; |
| self::$_builtInFormats[3] = '#,##0'; |
| self::$_builtInFormats[4] = '#,##0.00'; |
| self::$_builtInFormats[9] = '0%'; |
| self::$_builtInFormats[10] = '0.00%'; |
| self::$_builtInFormats[11] = '0.00E+00'; |
| self::$_builtInFormats[12] = '# ?/?'; |
| self::$_builtInFormats[13] = '# ??/??'; |
| self::$_builtInFormats[14] = 'mm-dd-yy'; |
| self::$_builtInFormats[15] = 'd-mmm-yy'; |
| self::$_builtInFormats[16] = 'd-mmm'; |
| self::$_builtInFormats[17] = 'mmm-yy'; |
| self::$_builtInFormats[18] = 'h:mm AM/PM'; |
| self::$_builtInFormats[19] = 'h:mm:ss AM/PM'; |
| self::$_builtInFormats[20] = 'h:mm'; |
| self::$_builtInFormats[21] = 'h:mm:ss'; |
| self::$_builtInFormats[22] = 'm/d/yy h:mm'; |
| self::$_builtInFormats[37] = '#,##0 ;(#,##0)'; |
| self::$_builtInFormats[38] = '#,##0 ;[Red](#,##0)'; |
| self::$_builtInFormats[39] = '#,##0.00;(#,##0.00)'; |
| self::$_builtInFormats[40] = '#,##0.00;[Red](#,##0.00)'; |
| self::$_builtInFormats[44] = '_("$"* #,##0.00_);_("$"* \(#,##0.00\);_("$"* "-"??_);_(@_)'; |
| self::$_builtInFormats[45] = 'mm:ss'; |
| self::$_builtInFormats[46] = '[h]:mm:ss'; |
| self::$_builtInFormats[47] = 'mmss.0'; |
| self::$_builtInFormats[48] = '##0.0E+0'; |
| self::$_builtInFormats[49] = '@'; |
| // CHT |
| self::$_builtInFormats[27] = '[$-404]e/m/d'; |
| self::$_builtInFormats[30] = 'm/d/yy'; |
| self::$_builtInFormats[36] = '[$-404]e/m/d'; |
| self::$_builtInFormats[50] = '[$-404]e/m/d'; |
| self::$_builtInFormats[57] = '[$-404]e/m/d'; |
| // THA |
| self::$_builtInFormats[59] = 't0'; |
| self::$_builtInFormats[60] = 't0.00'; |
| self::$_builtInFormats[61] = 't#,##0'; |
| self::$_builtInFormats[62] = 't#,##0.00'; |
| self::$_builtInFormats[67] = 't0%'; |
| self::$_builtInFormats[68] = 't0.00%'; |
| self::$_builtInFormats[69] = 't# ?/?'; |
| self::$_builtInFormats[70] = 't# ??/??'; |
| // Flip array (for faster lookups) |
| self::$_flippedBuiltInFormats = array_flip(self::$_builtInFormats); |
| } |
| } |
| /** |
| * Get built-in format code |
| * |
| * @param int $pIndex |
| * @return string |
| */ |
| public static function builtInFormatCode($pIndex) |
| { |
| // Clean parameter |
| $pIndex = intval($pIndex); |
| // Ensure built-in format codes are available |
| self::fillBuiltInFormatCodes(); |
| // Lookup format code |
| if (isset(self::$_builtInFormats[$pIndex])) { |
| return self::$_builtInFormats[$pIndex]; |
| } |
| return ''; |
| } |
| /** |
| * Get built-in format code index |
| * |
| * @param string $formatCode |
| * @return int|boolean |
| */ |
| public static function builtInFormatCodeIndex($formatCode) |
| { |
| // Ensure built-in format codes are available |
| self::fillBuiltInFormatCodes(); |
| // Lookup format code |
| if (isset(self::$_flippedBuiltInFormats[$formatCode])) { |
| return self::$_flippedBuiltInFormats[$formatCode]; |
| } |
| return false; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() |
| { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->_formatCode |
| . $this->_builtInFormatCode |
| . __CLASS__ |
| ); |
| } |
| /** |
| * Search/replace values to convert Excel date/time format masks to PHP format masks |
| * |
| * @var array |
| */ |
| private static $_dateFormatReplacements = array( |
| // first remove escapes related to non-format characters |
| '\\' => '', |
| // 12-hour suffix |
| 'am/pm' => 'A', |
| // 4-digit year |
| 'e' => 'Y', |
| 'yyyy' => 'Y', |
| // 2-digit year |
| 'yy' => 'y', |
| // first letter of month - no php equivalent |
| 'mmmmm' => 'M', |
| // full month name |
| 'mmmm' => 'F', |
| // short month name |
| 'mmm' => 'M', |
| // mm is minutes if time, but can also be month w/leading zero |
| // so we try to identify times be the inclusion of a : separator in the mask |
| // It isn't perfect, but the best way I know how |
| ':mm' => ':i', |
| 'mm:' => 'i:', |
| // month leading zero |
| 'mm' => 'm', |
| // month no leading zero |
| 'm' => 'n', |
| // full day of week name |
| 'dddd' => 'l', |
| // short day of week name |
| 'ddd' => 'D', |
| // days leading zero |
| 'dd' => 'd', |
| // days no leading zero |
| 'd' => 'j', |
| // seconds |
| 'ss' => 's', |
| // fractional seconds - no php equivalent |
| '.s' => '' |
| ); |
| /** |
| * Search/replace values to convert Excel date/time format masks hours to PHP format masks (24 hr clock) |
| * |
| * @var array |
| */ |
| private static $_dateFormatReplacements24 = array( |
| 'hh' => 'H', |
| 'h' => 'G' |
| ); |
| /** |
| * Search/replace values to convert Excel date/time format masks hours to PHP format masks (12 hr clock) |
| * |
| * @var array |
| */ |
| private static $_dateFormatReplacements12 = array( |
| 'hh' => 'h', |
| 'h' => 'g' |
| ); |
| private static function _formatAsDate(&$value, &$format) |
| { |
| // dvc: convert Excel formats to PHP date formats |
| // strip off first part containing e.g. [$-F800] or [$USD-409] |
| // general syntax: [$<Currency string>-<language info>] |
| // language info is in hexadecimal |
| $format = preg_replace('/^(\[\$[A-Z]*-[0-9A-F]*\])/i', '', $format); |
| // OpenOffice.org uses upper-case number formats, e.g. 'YYYY', convert to lower-case |
| $format = strtolower($format); |
| $format = strtr($format,self::$_dateFormatReplacements); |
| if (!strpos($format,'A')) { // 24-hour time format |
| $format = strtr($format,self::$_dateFormatReplacements24); |
| } else { // 12-hour time format |
| $format = strtr($format,self::$_dateFormatReplacements12); |
| } |
| $dateObj = PHPExcel_Shared_Date::ExcelToPHPObject($value); |
| $value = $dateObj->format($format); |
| } |
| private static function _formatAsPercentage(&$value, &$format) |
| { |
| if ($format === self::FORMAT_PERCENTAGE) { |
| $value = round( (100 * $value), 0) . '%'; |
| } else { |
| if (preg_match('/\.[#0]+/i', $format, $m)) { |
| $s = substr($m[0], 0, 1) . (strlen($m[0]) - 1); |
| $format = str_replace($m[0], $s, $format); |
| } |
| if (preg_match('/^[#0]+/', $format, $m)) { |
| $format = str_replace($m[0], strlen($m[0]), $format); |
| } |
| $format = '%' . str_replace('%', 'f%%', $format); |
| $value = sprintf($format, 100 * $value); |
| } |
| } |
| private static function _formatAsFraction(&$value, &$format) |
| { |
| $sign = ($value < 0) ? '-' : ''; |
| $integerPart = floor(abs($value)); |
| $decimalPart = trim(fmod(abs($value),1),'0.'); |
| $decimalLength = strlen($decimalPart); |
| $decimalDivisor = pow(10,$decimalLength); |
| $GCD = PHPExcel_Calculation_MathTrig::GCD($decimalPart,$decimalDivisor); |
| $adjustedDecimalPart = $decimalPart/$GCD; |
| $adjustedDecimalDivisor = $decimalDivisor/$GCD; |
| if ((strpos($format,'0') !== false) || (strpos($format,'#') !== false) || (substr($format,0,3) == '? ?')) { |
| if ($integerPart == 0) { |
| $integerPart = ''; |
| } |
| $value = "$sign$integerPart $adjustedDecimalPart/$adjustedDecimalDivisor"; |
| } else { |
| $adjustedDecimalPart += $integerPart * $adjustedDecimalDivisor; |
| $value = "$sign$adjustedDecimalPart/$adjustedDecimalDivisor"; |
| } |
| } |
| private static function _complexNumberFormatMask($number, $mask) { |
| if (strpos($mask,'.') !== false) { |
| $numbers = explode('.', $number . '.0'); |
| $masks = explode('.', $mask . '.0'); |
| $result1 = self::_complexNumberFormatMask($numbers[0], $masks[0]); |
| $result2 = strrev(self::_complexNumberFormatMask(strrev($numbers[1]), strrev($masks[1]))); |
| return $result1 . '.' . $result2; |
| } |
| $r = preg_match_all('/0+/', $mask, $result, PREG_OFFSET_CAPTURE); |
| if ($r > 1) { |
| $result = array_reverse($result[0]); |
| foreach($result as $block) { |
| $divisor = 1 . $block[0]; |
| $size = strlen($block[0]); |
| $offset = $block[1]; |
| $blockValue = sprintf( |
| '%0' . $size . 'd', |
| fmod($number, $divisor) |
| ); |
| $number = floor($number / $divisor); |
| $mask = substr_replace($mask,$blockValue, $offset, $size); |
| } |
| if ($number > 0) { |
| $mask = substr_replace($mask, $number, $offset, 0); |
| } |
| $result = $mask; |
| } else { |
| $result = $number; |
| } |
| return $result; |
| } |
| /** |
| * Convert a value in a pre-defined format to a PHP string |
| * |
| * @param mixed $value Value to format |
| * @param string $format Format code |
| * @param array $callBack Callback function for additional formatting of string |
| * @return string Formatted string |
| */ |
| public static function toFormattedString($value = '0', $format = PHPExcel_Style_NumberFormat::FORMAT_GENERAL, $callBack = null) |
| { |
| // For now we do not treat strings although section 4 of a format code affects strings |
| if (!is_numeric($value)) return $value; |
| // For 'General' format code, we just pass the value although this is not entirely the way Excel does it, |
| // it seems to round numbers to a total of 10 digits. |
| if (($format === PHPExcel_Style_NumberFormat::FORMAT_GENERAL) || ($format === PHPExcel_Style_NumberFormat::FORMAT_TEXT)) { |
| return $value; |
| } |
| // Get the sections, there can be up to four sections |
| $sections = explode(';', $format); |
| // Fetch the relevant section depending on whether number is positive, negative, or zero? |
| // Text not supported yet. |
| // Here is how the sections apply to various values in Excel: |
| // 1 section: [POSITIVE/NEGATIVE/ZERO/TEXT] |
| // 2 sections: [POSITIVE/ZERO/TEXT] [NEGATIVE] |
| // 3 sections: [POSITIVE/TEXT] [NEGATIVE] [ZERO] |
| // 4 sections: [POSITIVE] [NEGATIVE] [ZERO] [TEXT] |
| switch (count($sections)) { |
| case 1: |
| $format = $sections[0]; |
| break; |
| case 2: |
| $format = ($value >= 0) ? $sections[0] : $sections[1]; |
| $value = abs($value); // Use the absolute value |
| break; |
| case 3: |
| $format = ($value > 0) ? |
| $sections[0] : ( ($value < 0) ? |
| $sections[1] : $sections[2]); |
| $value = abs($value); // Use the absolute value |
| break; |
| case 4: |
| $format = ($value > 0) ? |
| $sections[0] : ( ($value < 0) ? |
| $sections[1] : $sections[2]); |
| $value = abs($value); // Use the absolute value |
| break; |
| default: |
| // something is wrong, just use first section |
| $format = $sections[0]; |
| break; |
| } |
| // Save format with color information for later use below |
| $formatColor = $format; |
| // Strip color information |
| $color_regex = '/^\\[[a-zA-Z]+\\]/'; |
| $format = preg_replace($color_regex, '', $format); |
| // Let's begin inspecting the format and converting the value to a formatted string |
| if (preg_match('/^(\[\$[A-Z]*-[0-9A-F]*\])*[hmsdy]/i', $format)) { // datetime format |
| self::_formatAsDate($value, $format); |
| } else if (preg_match('/%$/', $format)) { // % number format |
| self::_formatAsPercentage($value, $format); |
| } else { |
| if ($format === self::FORMAT_CURRENCY_EUR_SIMPLE) { |
| $value = 'EUR ' . sprintf('%1.2f', $value); |
| } else { |
| // In Excel formats, "_" is used to add spacing, which we can't do in HTML |
| $format = preg_replace('/_./', '', $format); |
| // Some non-number characters are escaped with \, which we don't need |
| $format = preg_replace("/\\\\/", '', $format); |
| // Some non-number strings are quoted, so we'll get rid of the quotes, likewise any positional * symbols |
| $format = str_replace(array('"','*'), '', $format); |
| // Find out if we need thousands separator |
| // This is indicated by a comma enclosed by a digit placeholder: |
| // #,# or 0,0 |
| $useThousands = preg_match('/(#,#|0,0)/', $format); |
| if ($useThousands) { |
| $format = preg_replace('/0,0/', '00', $format); |
| $format = preg_replace('/#,#/', '##', $format); |
| } |
| // Scale thousands, millions,... |
| // This is indicated by a number of commas after a digit placeholder: |
| // #, or 0.0,, |
| $scale = 1; // same as no scale |
| $matches = array(); |
| if (preg_match('/(#|0)(,+)/', $format, $matches)) { |
| $scale = pow(1000, strlen($matches[2])); |
| // strip the commas |
| $format = preg_replace('/0,+/', '0', $format); |
| $format = preg_replace('/#,+/', '#', $format); |
| } |
| if (preg_match('/#?.*\?\/\?/', $format, $m)) { |
| //echo 'Format mask is fractional '.$format.' <br />'; |
| if ($value != (int)$value) { |
| self::_formatAsFraction($value, $format); |
| } |
| } else { |
| // Handle the number itself |
| // scale number |
| $value = $value / $scale; |
| // Strip # |
| $format = preg_replace('/\\#/', '0', $format); |
| $n = "/\[[^\]]+\]/"; |
| $m = preg_replace($n, '', $format); |
| $number_regex = "/(0+)(\.?)(0*)/"; |
| if (preg_match($number_regex, $m, $matches)) { |
| $left = $matches[1]; |
| $dec = $matches[2]; |
| $right = $matches[3]; |
| // minimun width of formatted number (including dot) |
| $minWidth = strlen($left) + strlen($dec) + strlen($right); |
| if ($useThousands) { |
| $value = number_format( |
| $value |
| , strlen($right) |
| , PHPExcel_Shared_String::getDecimalSeparator() |
| , PHPExcel_Shared_String::getThousandsSeparator() |
| ); |
| $value = preg_replace($number_regex, $value, $format); |
| } else { |
| if (preg_match('/0([^\d\.]+)0/', $format, $matches)) { |
| $value = self::_complexNumberFormatMask($value, $format); |
| } else { |
| $sprintf_pattern = "%0$minWidth." . strlen($right) . "f"; |
| $value = sprintf($sprintf_pattern, $value); |
| $value = preg_replace($number_regex, $value, $format); |
| } |
| } |
| } |
| } |
| if (preg_match('/\[\$(.*)\]/u', $format, $m)) { |
| // Currency or Accounting |
| $currencyFormat = $m[0]; |
| $currencyCode = $m[1]; |
| list($currencyCode) = explode('-',$currencyCode); |
| if ($currencyCode == '') { |
| $currencyCode = PHPExcel_Shared_String::getCurrencyCode(); |
| } |
| $value = preg_replace('/\[\$([^\]]*)\]/u',$currencyCode,$value); |
| } |
| } |
| } |
| // Additional formatting provided by callback function |
| if ($callBack !== null) { |
| list($writerInstance, $function) = $callBack; |
| $value = $writerInstance->$function($value, $formatColor); |
| } |
| return $value; |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Supervisor.php |
|---|
| New file |
| 0,0 → 1,132 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Supervisor |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| abstract class PHPExcel_Style_Supervisor |
| { |
| /** |
| * Supervisor? |
| * |
| * @var boolean |
| */ |
| protected $_isSupervisor; |
| /** |
| * Parent. Only used for supervisor |
| * |
| * @var PHPExcel_Style |
| */ |
| protected $_parent; |
| /** |
| * Create a new PHPExcel_Style_Alignment |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE) |
| { |
| // Supervisor? |
| $this->_isSupervisor = $isSupervisor; |
| } |
| /** |
| * Bind parent. Only used for supervisor |
| * |
| * @param PHPExcel $parent |
| * @return PHPExcel_Style_Supervisor |
| */ |
| public function bindParent($parent, $parentPropertyName=NULL) |
| { |
| $this->_parent = $parent; |
| return $this; |
| } |
| /** |
| * Is this a supervisor or a cell style component? |
| * |
| * @return boolean |
| */ |
| public function getIsSupervisor() |
| { |
| return $this->_isSupervisor; |
| } |
| /** |
| * Get the currently active sheet. Only used for supervisor |
| * |
| * @return PHPExcel_Worksheet |
| */ |
| public function getActiveSheet() |
| { |
| return $this->_parent->getActiveSheet(); |
| } |
| /** |
| * Get the currently active cell coordinate in currently active sheet. |
| * Only used for supervisor |
| * |
| * @return string E.g. 'A1' |
| */ |
| public function getSelectedCells() |
| { |
| return $this->getActiveSheet()->getSelectedCells(); |
| } |
| /** |
| * Get the currently active cell coordinate in currently active sheet. |
| * Only used for supervisor |
| * |
| * @return string E.g. 'A1' |
| */ |
| public function getActiveCell() |
| { |
| return $this->getActiveSheet()->getActiveCell(); |
| } |
| /** |
| * 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)) && ($key != '_parent')) { |
| $this->$key = clone $value; |
| } else { |
| $this->$key = $value; |
| } |
| } |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Conditional.php |
|---|
| New file |
| 0,0 → 1,277 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Conditional |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Conditional implements PHPExcel_IComparable |
| { |
| /* Condition types */ |
| const CONDITION_NONE = 'none'; |
| const CONDITION_CELLIS = 'cellIs'; |
| const CONDITION_CONTAINSTEXT = 'containsText'; |
| const CONDITION_EXPRESSION = 'expression'; |
| /* Operator types */ |
| const OPERATOR_NONE = ''; |
| const OPERATOR_BEGINSWITH = 'beginsWith'; |
| const OPERATOR_ENDSWITH = 'endsWith'; |
| const OPERATOR_EQUAL = 'equal'; |
| const OPERATOR_GREATERTHAN = 'greaterThan'; |
| const OPERATOR_GREATERTHANOREQUAL = 'greaterThanOrEqual'; |
| const OPERATOR_LESSTHAN = 'lessThan'; |
| const OPERATOR_LESSTHANOREQUAL = 'lessThanOrEqual'; |
| const OPERATOR_NOTEQUAL = 'notEqual'; |
| const OPERATOR_CONTAINSTEXT = 'containsText'; |
| const OPERATOR_NOTCONTAINS = 'notContains'; |
| const OPERATOR_BETWEEN = 'between'; |
| /** |
| * Condition type |
| * |
| * @var int |
| */ |
| private $_conditionType; |
| /** |
| * Operator type |
| * |
| * @var int |
| */ |
| private $_operatorType; |
| /** |
| * Text |
| * |
| * @var string |
| */ |
| private $_text; |
| /** |
| * Condition |
| * |
| * @var string[] |
| */ |
| private $_condition = array(); |
| /** |
| * Style |
| * |
| * @var PHPExcel_Style |
| */ |
| private $_style; |
| /** |
| * Create a new PHPExcel_Style_Conditional |
| */ |
| public function __construct() |
| { |
| // Initialise values |
| $this->_conditionType = PHPExcel_Style_Conditional::CONDITION_NONE; |
| $this->_operatorType = PHPExcel_Style_Conditional::OPERATOR_NONE; |
| $this->_text = null; |
| $this->_condition = array(); |
| $this->_style = new PHPExcel_Style(FALSE, TRUE); |
| } |
| /** |
| * Get Condition type |
| * |
| * @return string |
| */ |
| public function getConditionType() { |
| return $this->_conditionType; |
| } |
| /** |
| * Set Condition type |
| * |
| * @param string $pValue PHPExcel_Style_Conditional condition type |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function setConditionType($pValue = PHPExcel_Style_Conditional::CONDITION_NONE) { |
| $this->_conditionType = $pValue; |
| return $this; |
| } |
| /** |
| * Get Operator type |
| * |
| * @return string |
| */ |
| public function getOperatorType() { |
| return $this->_operatorType; |
| } |
| /** |
| * Set Operator type |
| * |
| * @param string $pValue PHPExcel_Style_Conditional operator type |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function setOperatorType($pValue = PHPExcel_Style_Conditional::OPERATOR_NONE) { |
| $this->_operatorType = $pValue; |
| return $this; |
| } |
| /** |
| * Get text |
| * |
| * @return string |
| */ |
| public function getText() { |
| return $this->_text; |
| } |
| /** |
| * Set text |
| * |
| * @param string $value |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function setText($value = null) { |
| $this->_text = $value; |
| return $this; |
| } |
| /** |
| * Get Condition |
| * |
| * @deprecated Deprecated, use getConditions instead |
| * @return string |
| */ |
| public function getCondition() { |
| if (isset($this->_condition[0])) { |
| return $this->_condition[0]; |
| } |
| return ''; |
| } |
| /** |
| * Set Condition |
| * |
| * @deprecated Deprecated, use setConditions instead |
| * @param string $pValue Condition |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function setCondition($pValue = '') { |
| if (!is_array($pValue)) |
| $pValue = array($pValue); |
| return $this->setConditions($pValue); |
| } |
| /** |
| * Get Conditions |
| * |
| * @return string[] |
| */ |
| public function getConditions() { |
| return $this->_condition; |
| } |
| /** |
| * Set Conditions |
| * |
| * @param string[] $pValue Condition |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function setConditions($pValue) { |
| if (!is_array($pValue)) |
| $pValue = array($pValue); |
| $this->_condition = $pValue; |
| return $this; |
| } |
| /** |
| * Add Condition |
| * |
| * @param string $pValue Condition |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function addCondition($pValue = '') { |
| $this->_condition[] = $pValue; |
| return $this; |
| } |
| /** |
| * Get Style |
| * |
| * @return PHPExcel_Style |
| */ |
| public function getStyle() { |
| return $this->_style; |
| } |
| /** |
| * Set Style |
| * |
| * @param PHPExcel_Style $pValue |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Conditional |
| */ |
| public function setStyle(PHPExcel_Style $pValue = null) { |
| $this->_style = $pValue; |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| return md5( |
| $this->_conditionType |
| . $this->_operatorType |
| . implode(';', $this->_condition) |
| . $this->_style->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; |
| } |
| } |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Fill.php |
|---|
| New file |
| 0,0 → 1,321 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Fill |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Fill extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Fill types */ |
| const FILL_NONE = 'none'; |
| const FILL_SOLID = 'solid'; |
| const FILL_GRADIENT_LINEAR = 'linear'; |
| const FILL_GRADIENT_PATH = 'path'; |
| const FILL_PATTERN_DARKDOWN = 'darkDown'; |
| const FILL_PATTERN_DARKGRAY = 'darkGray'; |
| const FILL_PATTERN_DARKGRID = 'darkGrid'; |
| const FILL_PATTERN_DARKHORIZONTAL = 'darkHorizontal'; |
| const FILL_PATTERN_DARKTRELLIS = 'darkTrellis'; |
| const FILL_PATTERN_DARKUP = 'darkUp'; |
| const FILL_PATTERN_DARKVERTICAL = 'darkVertical'; |
| const FILL_PATTERN_GRAY0625 = 'gray0625'; |
| const FILL_PATTERN_GRAY125 = 'gray125'; |
| const FILL_PATTERN_LIGHTDOWN = 'lightDown'; |
| const FILL_PATTERN_LIGHTGRAY = 'lightGray'; |
| const FILL_PATTERN_LIGHTGRID = 'lightGrid'; |
| const FILL_PATTERN_LIGHTHORIZONTAL = 'lightHorizontal'; |
| const FILL_PATTERN_LIGHTTRELLIS = 'lightTrellis'; |
| const FILL_PATTERN_LIGHTUP = 'lightUp'; |
| const FILL_PATTERN_LIGHTVERTICAL = 'lightVertical'; |
| const FILL_PATTERN_MEDIUMGRAY = 'mediumGray'; |
| /** |
| * Fill type |
| * |
| * @var string |
| */ |
| protected $_fillType = PHPExcel_Style_Fill::FILL_NONE; |
| /** |
| * Rotation |
| * |
| * @var double |
| */ |
| protected $_rotation = 0; |
| /** |
| * Start color |
| * |
| * @var PHPExcel_Style_Color |
| */ |
| protected $_startColor; |
| /** |
| * End color |
| * |
| * @var PHPExcel_Style_Color |
| */ |
| protected $_endColor; |
| /** |
| * Create a new PHPExcel_Style_Fill |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| // Initialise values |
| if ($isConditional) { |
| $this->_fillType = NULL; |
| } |
| $this->_startColor = new PHPExcel_Style_Color(PHPExcel_Style_Color::COLOR_WHITE, $isSupervisor, $isConditional); |
| $this->_endColor = new PHPExcel_Style_Color(PHPExcel_Style_Color::COLOR_BLACK, $isSupervisor, $isConditional); |
| // bind parent if we are a supervisor |
| if ($isSupervisor) { |
| $this->_startColor->bindParent($this, '_startColor'); |
| $this->_endColor->bindParent($this, '_endColor'); |
| } |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Fill |
| */ |
| public function getSharedComponent() |
| { |
| return $this->_parent->getSharedComponent()->getFill(); |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| return array('fill' => $array); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getFill()->applyFromArray( |
| * array( |
| * 'type' => PHPExcel_Style_Fill::FILL_GRADIENT_LINEAR, |
| * 'rotation' => 0, |
| * 'startcolor' => array( |
| * 'rgb' => '000000' |
| * ), |
| * 'endcolor' => array( |
| * 'argb' => 'FFFFFFFF' |
| * ) |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Fill |
| */ |
| public function applyFromArray($pStyles = null) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (array_key_exists('type', $pStyles)) { |
| $this->setFillType($pStyles['type']); |
| } |
| if (array_key_exists('rotation', $pStyles)) { |
| $this->setRotation($pStyles['rotation']); |
| } |
| if (array_key_exists('startcolor', $pStyles)) { |
| $this->getStartColor()->applyFromArray($pStyles['startcolor']); |
| } |
| if (array_key_exists('endcolor', $pStyles)) { |
| $this->getEndColor()->applyFromArray($pStyles['endcolor']); |
| } |
| if (array_key_exists('color', $pStyles)) { |
| $this->getStartColor()->applyFromArray($pStyles['color']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get Fill Type |
| * |
| * @return string |
| */ |
| public function getFillType() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getFillType(); |
| } |
| return $this->_fillType; |
| } |
| /** |
| * Set Fill Type |
| * |
| * @param string $pValue PHPExcel_Style_Fill fill type |
| * @return PHPExcel_Style_Fill |
| */ |
| public function setFillType($pValue = PHPExcel_Style_Fill::FILL_NONE) { |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('type' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_fillType = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Rotation |
| * |
| * @return double |
| */ |
| public function getRotation() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getRotation(); |
| } |
| return $this->_rotation; |
| } |
| /** |
| * Set Rotation |
| * |
| * @param double $pValue |
| * @return PHPExcel_Style_Fill |
| */ |
| public function setRotation($pValue = 0) { |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('rotation' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_rotation = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Start Color |
| * |
| * @return PHPExcel_Style_Color |
| */ |
| public function getStartColor() { |
| return $this->_startColor; |
| } |
| /** |
| * Set Start Color |
| * |
| * @param PHPExcel_Style_Color $pValue |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Fill |
| */ |
| public function setStartColor(PHPExcel_Style_Color $pValue = null) { |
| // make sure parameter is a real color and not a supervisor |
| $color = $pValue->getIsSupervisor() ? $pValue->getSharedComponent() : $pValue; |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStartColor()->getStyleArray(array('argb' => $color->getARGB())); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_startColor = $color; |
| } |
| return $this; |
| } |
| /** |
| * Get End Color |
| * |
| * @return PHPExcel_Style_Color |
| */ |
| public function getEndColor() { |
| return $this->_endColor; |
| } |
| /** |
| * Set End Color |
| * |
| * @param PHPExcel_Style_Color $pValue |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Fill |
| */ |
| public function setEndColor(PHPExcel_Style_Color $pValue = null) { |
| // make sure parameter is a real color and not a supervisor |
| $color = $pValue->getIsSupervisor() ? $pValue->getSharedComponent() : $pValue; |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getEndColor()->getStyleArray(array('argb' => $color->getARGB())); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_endColor = $color; |
| } |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->getFillType() |
| . $this->getRotation() |
| . $this->getStartColor()->getHashCode() |
| . $this->getEndColor()->getHashCode() |
| . __CLASS__ |
| ); |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Font.php |
|---|
| New file |
| 0,0 → 1,532 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Font |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Font extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Underline types */ |
| const UNDERLINE_NONE = 'none'; |
| const UNDERLINE_DOUBLE = 'double'; |
| const UNDERLINE_DOUBLEACCOUNTING = 'doubleAccounting'; |
| const UNDERLINE_SINGLE = 'single'; |
| const UNDERLINE_SINGLEACCOUNTING = 'singleAccounting'; |
| /** |
| * Font Name |
| * |
| * @var string |
| */ |
| protected $_name = 'Calibri'; |
| /** |
| * Font Size |
| * |
| * @var float |
| */ |
| protected $_size = 11; |
| /** |
| * Bold |
| * |
| * @var boolean |
| */ |
| protected $_bold = FALSE; |
| /** |
| * Italic |
| * |
| * @var boolean |
| */ |
| protected $_italic = FALSE; |
| /** |
| * Superscript |
| * |
| * @var boolean |
| */ |
| protected $_superScript = FALSE; |
| /** |
| * Subscript |
| * |
| * @var boolean |
| */ |
| protected $_subScript = FALSE; |
| /** |
| * Underline |
| * |
| * @var string |
| */ |
| protected $_underline = self::UNDERLINE_NONE; |
| /** |
| * Strikethrough |
| * |
| * @var boolean |
| */ |
| protected $_strikethrough = FALSE; |
| /** |
| * Foreground color |
| * |
| * @var PHPExcel_Style_Color |
| */ |
| protected $_color; |
| /** |
| * Create a new PHPExcel_Style_Font |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| // Initialise values |
| if ($isConditional) { |
| $this->_name = NULL; |
| $this->_size = NULL; |
| $this->_bold = NULL; |
| $this->_italic = NULL; |
| $this->_superScript = NULL; |
| $this->_subScript = NULL; |
| $this->_underline = NULL; |
| $this->_strikethrough = NULL; |
| $this->_color = new PHPExcel_Style_Color(PHPExcel_Style_Color::COLOR_BLACK, $isSupervisor, $isConditional); |
| } else { |
| $this->_color = new PHPExcel_Style_Color(PHPExcel_Style_Color::COLOR_BLACK, $isSupervisor); |
| } |
| // bind parent if we are a supervisor |
| if ($isSupervisor) { |
| $this->_color->bindParent($this, '_color'); |
| } |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Font |
| */ |
| public function getSharedComponent() |
| { |
| return $this->_parent->getSharedComponent()->getFont(); |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| return array('font' => $array); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getFont()->applyFromArray( |
| * array( |
| * 'name' => 'Arial', |
| * 'bold' => TRUE, |
| * 'italic' => FALSE, |
| * 'underline' => PHPExcel_Style_Font::UNDERLINE_DOUBLE, |
| * 'strike' => FALSE, |
| * 'color' => array( |
| * 'rgb' => '808080' |
| * ) |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Font |
| */ |
| public function applyFromArray($pStyles = null) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (array_key_exists('name', $pStyles)) { |
| $this->setName($pStyles['name']); |
| } |
| if (array_key_exists('bold', $pStyles)) { |
| $this->setBold($pStyles['bold']); |
| } |
| if (array_key_exists('italic', $pStyles)) { |
| $this->setItalic($pStyles['italic']); |
| } |
| if (array_key_exists('superScript', $pStyles)) { |
| $this->setSuperScript($pStyles['superScript']); |
| } |
| if (array_key_exists('subScript', $pStyles)) { |
| $this->setSubScript($pStyles['subScript']); |
| } |
| if (array_key_exists('underline', $pStyles)) { |
| $this->setUnderline($pStyles['underline']); |
| } |
| if (array_key_exists('strike', $pStyles)) { |
| $this->setStrikethrough($pStyles['strike']); |
| } |
| if (array_key_exists('color', $pStyles)) { |
| $this->getColor()->applyFromArray($pStyles['color']); |
| } |
| if (array_key_exists('size', $pStyles)) { |
| $this->setSize($pStyles['size']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get Name |
| * |
| * @return string |
| */ |
| public function getName() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getName(); |
| } |
| return $this->_name; |
| } |
| /** |
| * Set Name |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setName($pValue = 'Calibri') { |
| if ($pValue == '') { |
| $pValue = 'Calibri'; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('name' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_name = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Size |
| * |
| * @return double |
| */ |
| public function getSize() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getSize(); |
| } |
| return $this->_size; |
| } |
| /** |
| * Set Size |
| * |
| * @param double $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setSize($pValue = 10) { |
| if ($pValue == '') { |
| $pValue = 10; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('size' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_size = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Bold |
| * |
| * @return boolean |
| */ |
| public function getBold() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getBold(); |
| } |
| return $this->_bold; |
| } |
| /** |
| * Set Bold |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setBold($pValue = false) { |
| if ($pValue == '') { |
| $pValue = false; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('bold' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_bold = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Italic |
| * |
| * @return boolean |
| */ |
| public function getItalic() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getItalic(); |
| } |
| return $this->_italic; |
| } |
| /** |
| * Set Italic |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setItalic($pValue = false) { |
| if ($pValue == '') { |
| $pValue = false; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('italic' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_italic = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get SuperScript |
| * |
| * @return boolean |
| */ |
| public function getSuperScript() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getSuperScript(); |
| } |
| return $this->_superScript; |
| } |
| /** |
| * Set SuperScript |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setSuperScript($pValue = false) { |
| if ($pValue == '') { |
| $pValue = false; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('superScript' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_superScript = $pValue; |
| $this->_subScript = !$pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get SubScript |
| * |
| * @return boolean |
| */ |
| public function getSubScript() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getSubScript(); |
| } |
| return $this->_subScript; |
| } |
| /** |
| * Set SubScript |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setSubScript($pValue = false) { |
| if ($pValue == '') { |
| $pValue = false; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('subScript' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_subScript = $pValue; |
| $this->_superScript = !$pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Underline |
| * |
| * @return string |
| */ |
| public function getUnderline() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getUnderline(); |
| } |
| return $this->_underline; |
| } |
| /** |
| * Set Underline |
| * |
| * @param string|boolean $pValue PHPExcel_Style_Font underline type |
| * If a boolean is passed, then TRUE equates to UNDERLINE_SINGLE, |
| * false equates to UNDERLINE_NONE |
| * @return PHPExcel_Style_Font |
| */ |
| public function setUnderline($pValue = self::UNDERLINE_NONE) { |
| if (is_bool($pValue)) { |
| $pValue = ($pValue) ? self::UNDERLINE_SINGLE : self::UNDERLINE_NONE; |
| } elseif ($pValue == '') { |
| $pValue = self::UNDERLINE_NONE; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('underline' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_underline = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Strikethrough |
| * |
| * @return boolean |
| */ |
| public function getStrikethrough() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getStrikethrough(); |
| } |
| return $this->_strikethrough; |
| } |
| /** |
| * Set Strikethrough |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Font |
| */ |
| public function setStrikethrough($pValue = false) { |
| if ($pValue == '') { |
| $pValue = false; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('strike' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_strikethrough = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Color |
| * |
| * @return PHPExcel_Style_Color |
| */ |
| public function getColor() { |
| return $this->_color; |
| } |
| /** |
| * Set Color |
| * |
| * @param PHPExcel_Style_Color $pValue |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Font |
| */ |
| public function setColor(PHPExcel_Style_Color $pValue = null) { |
| // make sure parameter is a real color and not a supervisor |
| $color = $pValue->getIsSupervisor() ? $pValue->getSharedComponent() : $pValue; |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getColor()->getStyleArray(array('argb' => $color->getARGB())); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_color = $color; |
| } |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->_name |
| . $this->_size |
| . ($this->_bold ? 't' : 'f') |
| . ($this->_italic ? 't' : 'f') |
| . ($this->_superScript ? 't' : 'f') |
| . ($this->_subScript ? 't' : 'f') |
| . $this->_underline |
| . ($this->_strikethrough ? 't' : 'f') |
| . $this->_color->getHashCode() |
| . __CLASS__ |
| ); |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Protection.php |
|---|
| New file |
| 0,0 → 1,207 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version 1.4.5, 2007-08-23 |
| */ |
| /** |
| * PHPExcel_Style_Protection |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Protection extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /** Protection styles */ |
| const PROTECTION_INHERIT = 'inherit'; |
| const PROTECTION_PROTECTED = 'protected'; |
| const PROTECTION_UNPROTECTED = 'unprotected'; |
| /** |
| * Locked |
| * |
| * @var string |
| */ |
| protected $_locked; |
| /** |
| * Hidden |
| * |
| * @var string |
| */ |
| protected $_hidden; |
| /** |
| * Create a new PHPExcel_Style_Protection |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| // Initialise values |
| if (!$isConditional) { |
| $this->_locked = self::PROTECTION_INHERIT; |
| $this->_hidden = self::PROTECTION_INHERIT; |
| } |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Protection |
| */ |
| public function getSharedComponent() |
| { |
| return $this->_parent->getSharedComponent()->getProtection(); |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| return array('protection' => $array); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getLocked()->applyFromArray( |
| * array( |
| * 'locked' => TRUE, |
| * 'hidden' => FALSE |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Protection |
| */ |
| public function applyFromArray($pStyles = NULL) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (isset($pStyles['locked'])) { |
| $this->setLocked($pStyles['locked']); |
| } |
| if (isset($pStyles['hidden'])) { |
| $this->setHidden($pStyles['hidden']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get locked |
| * |
| * @return string |
| */ |
| public function getLocked() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getLocked(); |
| } |
| return $this->_locked; |
| } |
| /** |
| * Set locked |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_Protection |
| */ |
| public function setLocked($pValue = self::PROTECTION_INHERIT) { |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('locked' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_locked = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get hidden |
| * |
| * @return string |
| */ |
| public function getHidden() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHidden(); |
| } |
| return $this->_hidden; |
| } |
| /** |
| * Set hidden |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_Protection |
| */ |
| public function setHidden($pValue = self::PROTECTION_INHERIT) { |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('hidden' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_hidden = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->_locked |
| . $this->_hidden |
| . __CLASS__ |
| ); |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Border.php |
|---|
| New file |
| 0,0 → 1,294 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Border |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Border extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Border style */ |
| const BORDER_NONE = 'none'; |
| const BORDER_DASHDOT = 'dashDot'; |
| const BORDER_DASHDOTDOT = 'dashDotDot'; |
| const BORDER_DASHED = 'dashed'; |
| const BORDER_DOTTED = 'dotted'; |
| const BORDER_DOUBLE = 'double'; |
| const BORDER_HAIR = 'hair'; |
| const BORDER_MEDIUM = 'medium'; |
| const BORDER_MEDIUMDASHDOT = 'mediumDashDot'; |
| const BORDER_MEDIUMDASHDOTDOT = 'mediumDashDotDot'; |
| const BORDER_MEDIUMDASHED = 'mediumDashed'; |
| const BORDER_SLANTDASHDOT = 'slantDashDot'; |
| const BORDER_THICK = 'thick'; |
| const BORDER_THIN = 'thin'; |
| /** |
| * Border style |
| * |
| * @var string |
| */ |
| protected $_borderStyle = PHPExcel_Style_Border::BORDER_NONE; |
| /** |
| * Border color |
| * |
| * @var PHPExcel_Style_Color |
| */ |
| protected $_color; |
| /** |
| * Parent property name |
| * |
| * @var string |
| */ |
| protected $_parentPropertyName; |
| /** |
| * Create a new PHPExcel_Style_Border |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| // Initialise values |
| $this->_color = new PHPExcel_Style_Color(PHPExcel_Style_Color::COLOR_BLACK, $isSupervisor); |
| // bind parent if we are a supervisor |
| if ($isSupervisor) { |
| $this->_color->bindParent($this, '_color'); |
| } |
| } |
| /** |
| * Bind parent. Only used for supervisor |
| * |
| * @param PHPExcel_Style_Borders $parent |
| * @param string $parentPropertyName |
| * @return PHPExcel_Style_Border |
| */ |
| public function bindParent($parent, $parentPropertyName=NULL) |
| { |
| $this->_parent = $parent; |
| $this->_parentPropertyName = $parentPropertyName; |
| return $this; |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Border |
| * @throws PHPExcel_Exception |
| */ |
| public function getSharedComponent() |
| { |
| switch ($this->_parentPropertyName) { |
| case '_allBorders': |
| case '_horizontal': |
| case '_inside': |
| case '_outline': |
| case '_vertical': |
| throw new PHPExcel_Exception('Cannot get shared component for a pseudo-border.'); |
| break; |
| case '_bottom': |
| return $this->_parent->getSharedComponent()->getBottom(); break; |
| case '_diagonal': |
| return $this->_parent->getSharedComponent()->getDiagonal(); break; |
| case '_left': |
| return $this->_parent->getSharedComponent()->getLeft(); break; |
| case '_right': |
| return $this->_parent->getSharedComponent()->getRight(); break; |
| case '_top': |
| return $this->_parent->getSharedComponent()->getTop(); break; |
| } |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| switch ($this->_parentPropertyName) { |
| case '_allBorders': |
| $key = 'allborders'; break; |
| case '_bottom': |
| $key = 'bottom'; break; |
| case '_diagonal': |
| $key = 'diagonal'; break; |
| case '_horizontal': |
| $key = 'horizontal'; break; |
| case '_inside': |
| $key = 'inside'; break; |
| case '_left': |
| $key = 'left'; break; |
| case '_outline': |
| $key = 'outline'; break; |
| case '_right': |
| $key = 'right'; break; |
| case '_top': |
| $key = 'top'; break; |
| case '_vertical': |
| $key = 'vertical'; break; |
| } |
| return $this->_parent->getStyleArray(array($key => $array)); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getBorders()->getTop()->applyFromArray( |
| * array( |
| * 'style' => PHPExcel_Style_Border::BORDER_DASHDOT, |
| * 'color' => array( |
| * 'rgb' => '808080' |
| * ) |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Border |
| */ |
| public function applyFromArray($pStyles = null) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (isset($pStyles['style'])) { |
| $this->setBorderStyle($pStyles['style']); |
| } |
| if (isset($pStyles['color'])) { |
| $this->getColor()->applyFromArray($pStyles['color']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get Border style |
| * |
| * @return string |
| */ |
| public function getBorderStyle() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getBorderStyle(); |
| } |
| return $this->_borderStyle; |
| } |
| /** |
| * Set Border style |
| * |
| * @param string|boolean $pValue |
| * When passing a boolean, FALSE equates PHPExcel_Style_Border::BORDER_NONE |
| * and TRUE to PHPExcel_Style_Border::BORDER_MEDIUM |
| * @return PHPExcel_Style_Border |
| */ |
| public function setBorderStyle($pValue = PHPExcel_Style_Border::BORDER_NONE) { |
| if (empty($pValue)) { |
| $pValue = PHPExcel_Style_Border::BORDER_NONE; |
| } elseif(is_bool($pValue) && $pValue) { |
| $pValue = PHPExcel_Style_Border::BORDER_MEDIUM; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('style' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_borderStyle = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Border Color |
| * |
| * @return PHPExcel_Style_Color |
| */ |
| public function getColor() { |
| return $this->_color; |
| } |
| /** |
| * Set Border Color |
| * |
| * @param PHPExcel_Style_Color $pValue |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Border |
| */ |
| public function setColor(PHPExcel_Style_Color $pValue = null) { |
| // make sure parameter is a real color and not a supervisor |
| $color = $pValue->getIsSupervisor() ? $pValue->getSharedComponent() : $pValue; |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getColor()->getStyleArray(array('argb' => $color->getARGB())); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_color = $color; |
| } |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->_borderStyle |
| . $this->_color->getHashCode() |
| . __CLASS__ |
| ); |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Alignment.php |
|---|
| New file |
| 0,0 → 1,409 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Alignment |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Alignment extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Horizontal alignment styles */ |
| const HORIZONTAL_GENERAL = 'general'; |
| const HORIZONTAL_LEFT = 'left'; |
| const HORIZONTAL_RIGHT = 'right'; |
| const HORIZONTAL_CENTER = 'center'; |
| const HORIZONTAL_CENTER_CONTINUOUS = 'centerContinuous'; |
| const HORIZONTAL_JUSTIFY = 'justify'; |
| /* Vertical alignment styles */ |
| const VERTICAL_BOTTOM = 'bottom'; |
| const VERTICAL_TOP = 'top'; |
| const VERTICAL_CENTER = 'center'; |
| const VERTICAL_JUSTIFY = 'justify'; |
| /** |
| * Horizontal |
| * |
| * @var string |
| */ |
| protected $_horizontal = PHPExcel_Style_Alignment::HORIZONTAL_GENERAL; |
| /** |
| * Vertical |
| * |
| * @var string |
| */ |
| protected $_vertical = PHPExcel_Style_Alignment::VERTICAL_BOTTOM; |
| /** |
| * Text rotation |
| * |
| * @var int |
| */ |
| protected $_textRotation = 0; |
| /** |
| * Wrap text |
| * |
| * @var boolean |
| */ |
| protected $_wrapText = FALSE; |
| /** |
| * Shrink to fit |
| * |
| * @var boolean |
| */ |
| protected $_shrinkToFit = FALSE; |
| /** |
| * Indent - only possible with horizontal alignment left and right |
| * |
| * @var int |
| */ |
| protected $_indent = 0; |
| /** |
| * Create a new PHPExcel_Style_Alignment |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| if ($isConditional) { |
| $this->_horizontal = NULL; |
| $this->_vertical = NULL; |
| $this->_textRotation = NULL; |
| } |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function getSharedComponent() |
| { |
| return $this->_parent->getSharedComponent()->getAlignment(); |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| return array('alignment' => $array); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getAlignment()->applyFromArray( |
| * array( |
| * 'horizontal' => PHPExcel_Style_Alignment::HORIZONTAL_CENTER, |
| * 'vertical' => PHPExcel_Style_Alignment::VERTICAL_CENTER, |
| * 'rotation' => 0, |
| * 'wrap' => TRUE |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function applyFromArray($pStyles = NULL) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells()) |
| ->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (isset($pStyles['horizontal'])) { |
| $this->setHorizontal($pStyles['horizontal']); |
| } |
| if (isset($pStyles['vertical'])) { |
| $this->setVertical($pStyles['vertical']); |
| } |
| if (isset($pStyles['rotation'])) { |
| $this->setTextRotation($pStyles['rotation']); |
| } |
| if (isset($pStyles['wrap'])) { |
| $this->setWrapText($pStyles['wrap']); |
| } |
| if (isset($pStyles['shrinkToFit'])) { |
| $this->setShrinkToFit($pStyles['shrinkToFit']); |
| } |
| if (isset($pStyles['indent'])) { |
| $this->setIndent($pStyles['indent']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get Horizontal |
| * |
| * @return string |
| */ |
| public function getHorizontal() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHorizontal(); |
| } |
| return $this->_horizontal; |
| } |
| /** |
| * Set Horizontal |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function setHorizontal($pValue = PHPExcel_Style_Alignment::HORIZONTAL_GENERAL) { |
| if ($pValue == '') { |
| $pValue = PHPExcel_Style_Alignment::HORIZONTAL_GENERAL; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('horizontal' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } |
| else { |
| $this->_horizontal = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Vertical |
| * |
| * @return string |
| */ |
| public function getVertical() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getVertical(); |
| } |
| return $this->_vertical; |
| } |
| /** |
| * Set Vertical |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function setVertical($pValue = PHPExcel_Style_Alignment::VERTICAL_BOTTOM) { |
| if ($pValue == '') { |
| $pValue = PHPExcel_Style_Alignment::VERTICAL_BOTTOM; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('vertical' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_vertical = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get TextRotation |
| * |
| * @return int |
| */ |
| public function getTextRotation() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getTextRotation(); |
| } |
| return $this->_textRotation; |
| } |
| /** |
| * Set TextRotation |
| * |
| * @param int $pValue |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function setTextRotation($pValue = 0) { |
| // Excel2007 value 255 => PHPExcel value -165 |
| if ($pValue == 255) { |
| $pValue = -165; |
| } |
| // Set rotation |
| if ( ($pValue >= -90 && $pValue <= 90) || $pValue == -165 ) { |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('rotation' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_textRotation = $pValue; |
| } |
| } else { |
| throw new PHPExcel_Exception("Text rotation should be a value between -90 and 90."); |
| } |
| return $this; |
| } |
| /** |
| * Get Wrap Text |
| * |
| * @return boolean |
| */ |
| public function getWrapText() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getWrapText(); |
| } |
| return $this->_wrapText; |
| } |
| /** |
| * Set Wrap Text |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function setWrapText($pValue = FALSE) { |
| if ($pValue == '') { |
| $pValue = FALSE; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('wrap' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_wrapText = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get Shrink to fit |
| * |
| * @return boolean |
| */ |
| public function getShrinkToFit() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getShrinkToFit(); |
| } |
| return $this->_shrinkToFit; |
| } |
| /** |
| * Set Shrink to fit |
| * |
| * @param boolean $pValue |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function setShrinkToFit($pValue = FALSE) { |
| if ($pValue == '') { |
| $pValue = FALSE; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('shrinkToFit' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_shrinkToFit = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get indent |
| * |
| * @return int |
| */ |
| public function getIndent() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getIndent(); |
| } |
| return $this->_indent; |
| } |
| /** |
| * Set indent |
| * |
| * @param int $pValue |
| * @return PHPExcel_Style_Alignment |
| */ |
| public function setIndent($pValue = 0) { |
| if ($pValue > 0) { |
| if ($this->getHorizontal() != self::HORIZONTAL_GENERAL && |
| $this->getHorizontal() != self::HORIZONTAL_LEFT && |
| $this->getHorizontal() != self::HORIZONTAL_RIGHT) { |
| $pValue = 0; // indent not supported |
| } |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('indent' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_indent = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->_horizontal |
| . $this->_vertical |
| . $this->_textRotation |
| . ($this->_wrapText ? 't' : 'f') |
| . ($this->_shrinkToFit ? 't' : 'f') |
| . $this->_indent |
| . __CLASS__ |
| ); |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Color.php |
|---|
| New file |
| 0,0 → 1,429 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Color |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Color extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Colors */ |
| const COLOR_BLACK = 'FF000000'; |
| const COLOR_WHITE = 'FFFFFFFF'; |
| const COLOR_RED = 'FFFF0000'; |
| const COLOR_DARKRED = 'FF800000'; |
| const COLOR_BLUE = 'FF0000FF'; |
| const COLOR_DARKBLUE = 'FF000080'; |
| const COLOR_GREEN = 'FF00FF00'; |
| const COLOR_DARKGREEN = 'FF008000'; |
| const COLOR_YELLOW = 'FFFFFF00'; |
| const COLOR_DARKYELLOW = 'FF808000'; |
| /** |
| * Indexed colors array |
| * |
| * @var array |
| */ |
| protected static $_indexedColors; |
| /** |
| * ARGB - Alpha RGB |
| * |
| * @var string |
| */ |
| protected $_argb = NULL; |
| /** |
| * Parent property name |
| * |
| * @var string |
| */ |
| protected $_parentPropertyName; |
| /** |
| * Create a new PHPExcel_Style_Color |
| * |
| * @param string $pARGB ARGB value for the colour |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($pARGB = PHPExcel_Style_Color::COLOR_BLACK, $isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| // Initialise values |
| if (!$isConditional) { |
| $this->_argb = $pARGB; |
| } |
| } |
| /** |
| * Bind parent. Only used for supervisor |
| * |
| * @param mixed $parent |
| * @param string $parentPropertyName |
| * @return PHPExcel_Style_Color |
| */ |
| public function bindParent($parent, $parentPropertyName=NULL) |
| { |
| $this->_parent = $parent; |
| $this->_parentPropertyName = $parentPropertyName; |
| return $this; |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Color |
| */ |
| public function getSharedComponent() |
| { |
| switch ($this->_parentPropertyName) { |
| case '_endColor': |
| return $this->_parent->getSharedComponent()->getEndColor(); break; |
| case '_color': |
| return $this->_parent->getSharedComponent()->getColor(); break; |
| case '_startColor': |
| return $this->_parent->getSharedComponent()->getStartColor(); break; |
| } |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| switch ($this->_parentPropertyName) { |
| case '_endColor': |
| $key = 'endcolor'; |
| break; |
| case '_color': |
| $key = 'color'; |
| break; |
| case '_startColor': |
| $key = 'startcolor'; |
| break; |
| } |
| return $this->_parent->getStyleArray(array($key => $array)); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getFont()->getColor()->applyFromArray( array('rgb' => '808080') ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Color |
| */ |
| public function applyFromArray($pStyles = NULL) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (array_key_exists('rgb', $pStyles)) { |
| $this->setRGB($pStyles['rgb']); |
| } |
| if (array_key_exists('argb', $pStyles)) { |
| $this->setARGB($pStyles['argb']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get ARGB |
| * |
| * @return string |
| */ |
| public function getARGB() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getARGB(); |
| } |
| return $this->_argb; |
| } |
| /** |
| * Set ARGB |
| * |
| * @param string $pValue |
| * @return PHPExcel_Style_Color |
| */ |
| public function setARGB($pValue = PHPExcel_Style_Color::COLOR_BLACK) { |
| if ($pValue == '') { |
| $pValue = PHPExcel_Style_Color::COLOR_BLACK; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('argb' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_argb = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get RGB |
| * |
| * @return string |
| */ |
| public function getRGB() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getRGB(); |
| } |
| return substr($this->_argb, 2); |
| } |
| /** |
| * Set RGB |
| * |
| * @param string $pValue RGB value |
| * @return PHPExcel_Style_Color |
| */ |
| public function setRGB($pValue = '000000') { |
| if ($pValue == '') { |
| $pValue = '000000'; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('argb' => 'FF' . $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_argb = 'FF' . $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get a specified colour component of an RGB value |
| * |
| * @private |
| * @param string $RGB The colour as an RGB value (e.g. FF00CCCC or CCDDEE |
| * @param int $offset Position within the RGB value to extract |
| * @param boolean $hex Flag indicating whether the component should be returned as a hex or a |
| * decimal value |
| * @return string The extracted colour component |
| */ |
| private static function _getColourComponent($RGB,$offset,$hex=TRUE) { |
| $colour = substr($RGB, $offset, 2); |
| if (!$hex) |
| $colour = hexdec($colour); |
| return $colour; |
| } |
| /** |
| * Get the red colour component of an RGB value |
| * |
| * @param string $RGB The colour as an RGB value (e.g. FF00CCCC or CCDDEE |
| * @param boolean $hex Flag indicating whether the component should be returned as a hex or a |
| * decimal value |
| * @return string The red colour component |
| */ |
| public static function getRed($RGB,$hex=TRUE) { |
| return self::_getColourComponent($RGB, strlen($RGB) - 6, $hex); |
| } |
| /** |
| * Get the green colour component of an RGB value |
| * |
| * @param string $RGB The colour as an RGB value (e.g. FF00CCCC or CCDDEE |
| * @param boolean $hex Flag indicating whether the component should be returned as a hex or a |
| * decimal value |
| * @return string The green colour component |
| */ |
| public static function getGreen($RGB,$hex=TRUE) { |
| return self::_getColourComponent($RGB, strlen($RGB) - 4, $hex); |
| } |
| /** |
| * Get the blue colour component of an RGB value |
| * |
| * @param string $RGB The colour as an RGB value (e.g. FF00CCCC or CCDDEE |
| * @param boolean $hex Flag indicating whether the component should be returned as a hex or a |
| * decimal value |
| * @return string The blue colour component |
| */ |
| public static function getBlue($RGB,$hex=TRUE) { |
| return self::_getColourComponent($RGB, strlen($RGB) - 2, $hex); |
| } |
| /** |
| * Adjust the brightness of a color |
| * |
| * @param string $hex The colour as an RGBA or RGB value (e.g. FF00CCCC or CCDDEE) |
| * @param float $adjustPercentage The percentage by which to adjust the colour as a float from -1 to 1 |
| * @return string The adjusted colour as an RGBA or RGB value (e.g. FF00CCCC or CCDDEE) |
| */ |
| public static function changeBrightness($hex, $adjustPercentage) { |
| $rgba = (strlen($hex) == 8); |
| $red = self::getRed($hex, FALSE); |
| $green = self::getGreen($hex, FALSE); |
| $blue = self::getBlue($hex, FALSE); |
| if ($adjustPercentage > 0) { |
| $red += (255 - $red) * $adjustPercentage; |
| $green += (255 - $green) * $adjustPercentage; |
| $blue += (255 - $blue) * $adjustPercentage; |
| } else { |
| $red += $red * $adjustPercentage; |
| $green += $green * $adjustPercentage; |
| $blue += $blue * $adjustPercentage; |
| } |
| if ($red < 0) $red = 0; |
| elseif ($red > 255) $red = 255; |
| if ($green < 0) $green = 0; |
| elseif ($green > 255) $green = 255; |
| if ($blue < 0) $blue = 0; |
| elseif ($blue > 255) $blue = 255; |
| $rgb = strtoupper( str_pad(dechex($red), 2, '0', 0) . |
| str_pad(dechex($green), 2, '0', 0) . |
| str_pad(dechex($blue), 2, '0', 0) |
| ); |
| return (($rgba) ? 'FF' : '') . $rgb; |
| } |
| /** |
| * Get indexed color |
| * |
| * @param int $pIndex Index entry point into the colour array |
| * @param boolean $background Flag to indicate whether default background or foreground colour |
| * should be returned if the indexed colour doesn't exist |
| * @return PHPExcel_Style_Color |
| */ |
| public static function indexedColor($pIndex, $background=FALSE) { |
| // Clean parameter |
| $pIndex = intval($pIndex); |
| // Indexed colors |
| if (is_null(self::$_indexedColors)) { |
| self::$_indexedColors = array( |
| 1 => 'FF000000', // System Colour #1 - Black |
| 2 => 'FFFFFFFF', // System Colour #2 - White |
| 3 => 'FFFF0000', // System Colour #3 - Red |
| 4 => 'FF00FF00', // System Colour #4 - Green |
| 5 => 'FF0000FF', // System Colour #5 - Blue |
| 6 => 'FFFFFF00', // System Colour #6 - Yellow |
| 7 => 'FFFF00FF', // System Colour #7- Magenta |
| 8 => 'FF00FFFF', // System Colour #8- Cyan |
| 9 => 'FF800000', // Standard Colour #9 |
| 10 => 'FF008000', // Standard Colour #10 |
| 11 => 'FF000080', // Standard Colour #11 |
| 12 => 'FF808000', // Standard Colour #12 |
| 13 => 'FF800080', // Standard Colour #13 |
| 14 => 'FF008080', // Standard Colour #14 |
| 15 => 'FFC0C0C0', // Standard Colour #15 |
| 16 => 'FF808080', // Standard Colour #16 |
| 17 => 'FF9999FF', // Chart Fill Colour #17 |
| 18 => 'FF993366', // Chart Fill Colour #18 |
| 19 => 'FFFFFFCC', // Chart Fill Colour #19 |
| 20 => 'FFCCFFFF', // Chart Fill Colour #20 |
| 21 => 'FF660066', // Chart Fill Colour #21 |
| 22 => 'FFFF8080', // Chart Fill Colour #22 |
| 23 => 'FF0066CC', // Chart Fill Colour #23 |
| 24 => 'FFCCCCFF', // Chart Fill Colour #24 |
| 25 => 'FF000080', // Chart Line Colour #25 |
| 26 => 'FFFF00FF', // Chart Line Colour #26 |
| 27 => 'FFFFFF00', // Chart Line Colour #27 |
| 28 => 'FF00FFFF', // Chart Line Colour #28 |
| 29 => 'FF800080', // Chart Line Colour #29 |
| 30 => 'FF800000', // Chart Line Colour #30 |
| 31 => 'FF008080', // Chart Line Colour #31 |
| 32 => 'FF0000FF', // Chart Line Colour #32 |
| 33 => 'FF00CCFF', // Standard Colour #33 |
| 34 => 'FFCCFFFF', // Standard Colour #34 |
| 35 => 'FFCCFFCC', // Standard Colour #35 |
| 36 => 'FFFFFF99', // Standard Colour #36 |
| 37 => 'FF99CCFF', // Standard Colour #37 |
| 38 => 'FFFF99CC', // Standard Colour #38 |
| 39 => 'FFCC99FF', // Standard Colour #39 |
| 40 => 'FFFFCC99', // Standard Colour #40 |
| 41 => 'FF3366FF', // Standard Colour #41 |
| 42 => 'FF33CCCC', // Standard Colour #42 |
| 43 => 'FF99CC00', // Standard Colour #43 |
| 44 => 'FFFFCC00', // Standard Colour #44 |
| 45 => 'FFFF9900', // Standard Colour #45 |
| 46 => 'FFFF6600', // Standard Colour #46 |
| 47 => 'FF666699', // Standard Colour #47 |
| 48 => 'FF969696', // Standard Colour #48 |
| 49 => 'FF003366', // Standard Colour #49 |
| 50 => 'FF339966', // Standard Colour #50 |
| 51 => 'FF003300', // Standard Colour #51 |
| 52 => 'FF333300', // Standard Colour #52 |
| 53 => 'FF993300', // Standard Colour #53 |
| 54 => 'FF993366', // Standard Colour #54 |
| 55 => 'FF333399', // Standard Colour #55 |
| 56 => 'FF333333' // Standard Colour #56 |
| ); |
| } |
| if (array_key_exists($pIndex, self::$_indexedColors)) { |
| return new PHPExcel_Style_Color(self::$_indexedColors[$pIndex]); |
| } |
| if ($background) { |
| return new PHPExcel_Style_Color('FFFFFFFF'); |
| } |
| return new PHPExcel_Style_Color('FF000000'); |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashCode(); |
| } |
| return md5( |
| $this->_argb |
| . __CLASS__ |
| ); |
| } |
| } |
| /branches/v2.25-scarificateur/jrest/lib/PHPExcel/Classes/PHPExcel/Style/Borders.php |
|---|
| New file |
| 0,0 → 1,424 |
| <?php |
| /** |
| * PHPExcel |
| * |
| * Copyright (c) 2006 - 2013 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_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
| * @version ##VERSION##, ##DATE## |
| */ |
| /** |
| * PHPExcel_Style_Borders |
| * |
| * @category PHPExcel |
| * @package PHPExcel_Style |
| * @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
| */ |
| class PHPExcel_Style_Borders extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable |
| { |
| /* Diagonal directions */ |
| const DIAGONAL_NONE = 0; |
| const DIAGONAL_UP = 1; |
| const DIAGONAL_DOWN = 2; |
| const DIAGONAL_BOTH = 3; |
| /** |
| * Left |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_left; |
| /** |
| * Right |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_right; |
| /** |
| * Top |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_top; |
| /** |
| * Bottom |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_bottom; |
| /** |
| * Diagonal |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_diagonal; |
| /** |
| * DiagonalDirection |
| * |
| * @var int |
| */ |
| protected $_diagonalDirection; |
| /** |
| * All borders psedo-border. Only applies to supervisor. |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_allBorders; |
| /** |
| * Outline psedo-border. Only applies to supervisor. |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_outline; |
| /** |
| * Inside psedo-border. Only applies to supervisor. |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_inside; |
| /** |
| * Vertical pseudo-border. Only applies to supervisor. |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_vertical; |
| /** |
| * Horizontal pseudo-border. Only applies to supervisor. |
| * |
| * @var PHPExcel_Style_Border |
| */ |
| protected $_horizontal; |
| /** |
| * Create a new PHPExcel_Style_Borders |
| * |
| * @param boolean $isSupervisor Flag indicating if this is a supervisor or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| * @param boolean $isConditional Flag indicating if this is a conditional style or not |
| * Leave this value at default unless you understand exactly what |
| * its ramifications are |
| */ |
| public function __construct($isSupervisor = FALSE, $isConditional = FALSE) |
| { |
| // Supervisor? |
| parent::__construct($isSupervisor); |
| // Initialise values |
| $this->_left = new PHPExcel_Style_Border($isSupervisor, $isConditional); |
| $this->_right = new PHPExcel_Style_Border($isSupervisor, $isConditional); |
| $this->_top = new PHPExcel_Style_Border($isSupervisor, $isConditional); |
| $this->_bottom = new PHPExcel_Style_Border($isSupervisor, $isConditional); |
| $this->_diagonal = new PHPExcel_Style_Border($isSupervisor, $isConditional); |
| $this->_diagonalDirection = PHPExcel_Style_Borders::DIAGONAL_NONE; |
| // Specially for supervisor |
| if ($isSupervisor) { |
| // Initialize pseudo-borders |
| $this->_allBorders = new PHPExcel_Style_Border(TRUE); |
| $this->_outline = new PHPExcel_Style_Border(TRUE); |
| $this->_inside = new PHPExcel_Style_Border(TRUE); |
| $this->_vertical = new PHPExcel_Style_Border(TRUE); |
| $this->_horizontal = new PHPExcel_Style_Border(TRUE); |
| // bind parent if we are a supervisor |
| $this->_left->bindParent($this, '_left'); |
| $this->_right->bindParent($this, '_right'); |
| $this->_top->bindParent($this, '_top'); |
| $this->_bottom->bindParent($this, '_bottom'); |
| $this->_diagonal->bindParent($this, '_diagonal'); |
| $this->_allBorders->bindParent($this, '_allBorders'); |
| $this->_outline->bindParent($this, '_outline'); |
| $this->_inside->bindParent($this, '_inside'); |
| $this->_vertical->bindParent($this, '_vertical'); |
| $this->_horizontal->bindParent($this, '_horizontal'); |
| } |
| } |
| /** |
| * Get the shared style component for the currently active cell in currently active sheet. |
| * Only used for style supervisor |
| * |
| * @return PHPExcel_Style_Borders |
| */ |
| public function getSharedComponent() |
| { |
| return $this->_parent->getSharedComponent()->getBorders(); |
| } |
| /** |
| * Build style array from subcomponents |
| * |
| * @param array $array |
| * @return array |
| */ |
| public function getStyleArray($array) |
| { |
| return array('borders' => $array); |
| } |
| /** |
| * Apply styles from array |
| * |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getBorders()->applyFromArray( |
| * array( |
| * 'bottom' => array( |
| * 'style' => PHPExcel_Style_Border::BORDER_DASHDOT, |
| * 'color' => array( |
| * 'rgb' => '808080' |
| * ) |
| * ), |
| * 'top' => array( |
| * 'style' => PHPExcel_Style_Border::BORDER_DASHDOT, |
| * 'color' => array( |
| * 'rgb' => '808080' |
| * ) |
| * ) |
| * ) |
| * ); |
| * </code> |
| * <code> |
| * $objPHPExcel->getActiveSheet()->getStyle('B2')->getBorders()->applyFromArray( |
| * array( |
| * 'allborders' => array( |
| * 'style' => PHPExcel_Style_Border::BORDER_DASHDOT, |
| * 'color' => array( |
| * 'rgb' => '808080' |
| * ) |
| * ) |
| * ) |
| * ); |
| * </code> |
| * |
| * @param array $pStyles Array containing style information |
| * @throws PHPExcel_Exception |
| * @return PHPExcel_Style_Borders |
| */ |
| public function applyFromArray($pStyles = null) { |
| if (is_array($pStyles)) { |
| if ($this->_isSupervisor) { |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($this->getStyleArray($pStyles)); |
| } else { |
| if (array_key_exists('left', $pStyles)) { |
| $this->getLeft()->applyFromArray($pStyles['left']); |
| } |
| if (array_key_exists('right', $pStyles)) { |
| $this->getRight()->applyFromArray($pStyles['right']); |
| } |
| if (array_key_exists('top', $pStyles)) { |
| $this->getTop()->applyFromArray($pStyles['top']); |
| } |
| if (array_key_exists('bottom', $pStyles)) { |
| $this->getBottom()->applyFromArray($pStyles['bottom']); |
| } |
| if (array_key_exists('diagonal', $pStyles)) { |
| $this->getDiagonal()->applyFromArray($pStyles['diagonal']); |
| } |
| if (array_key_exists('diagonaldirection', $pStyles)) { |
| $this->setDiagonalDirection($pStyles['diagonaldirection']); |
| } |
| if (array_key_exists('allborders', $pStyles)) { |
| $this->getLeft()->applyFromArray($pStyles['allborders']); |
| $this->getRight()->applyFromArray($pStyles['allborders']); |
| $this->getTop()->applyFromArray($pStyles['allborders']); |
| $this->getBottom()->applyFromArray($pStyles['allborders']); |
| } |
| } |
| } else { |
| throw new PHPExcel_Exception("Invalid style array passed."); |
| } |
| return $this; |
| } |
| /** |
| * Get Left |
| * |
| * @return PHPExcel_Style_Border |
| */ |
| public function getLeft() { |
| return $this->_left; |
| } |
| /** |
| * Get Right |
| * |
| * @return PHPExcel_Style_Border |
| */ |
| public function getRight() { |
| return $this->_right; |
| } |
| /** |
| * Get Top |
| * |
| * @return PHPExcel_Style_Border |
| */ |
| public function getTop() { |
| return $this->_top; |
| } |
| /** |
| * Get Bottom |
| * |
| * @return PHPExcel_Style_Border |
| */ |
| public function getBottom() { |
| return $this->_bottom; |
| } |
| /** |
| * Get Diagonal |
| * |
| * @return PHPExcel_Style_Border |
| */ |
| public function getDiagonal() { |
| return $this->_diagonal; |
| } |
| /** |
| * Get AllBorders (pseudo-border). Only applies to supervisor. |
| * |
| * @return PHPExcel_Style_Border |
| * @throws PHPExcel_Exception |
| */ |
| public function getAllBorders() { |
| if (!$this->_isSupervisor) { |
| throw new PHPExcel_Exception('Can only get pseudo-border for supervisor.'); |
| } |
| return $this->_allBorders; |
| } |
| /** |
| * Get Outline (pseudo-border). Only applies to supervisor. |
| * |
| * @return boolean |
| * @throws PHPExcel_Exception |
| */ |
| public function getOutline() { |
| if (!$this->_isSupervisor) { |
| throw new PHPExcel_Exception('Can only get pseudo-border for supervisor.'); |
| } |
| return $this->_outline; |
| } |
| /** |
| * Get Inside (pseudo-border). Only applies to supervisor. |
| * |
| * @return boolean |
| * @throws PHPExcel_Exception |
| */ |
| public function getInside() { |
| if (!$this->_isSupervisor) { |
| throw new PHPExcel_Exception('Can only get pseudo-border for supervisor.'); |
| } |
| return $this->_inside; |
| } |
| /** |
| * Get Vertical (pseudo-border). Only applies to supervisor. |
| * |
| * @return PHPExcel_Style_Border |
| * @throws PHPExcel_Exception |
| */ |
| public function getVertical() { |
| if (!$this->_isSupervisor) { |
| throw new PHPExcel_Exception('Can only get pseudo-border for supervisor.'); |
| } |
| return $this->_vertical; |
| } |
| /** |
| * Get Horizontal (pseudo-border). Only applies to supervisor. |
| * |
| * @return PHPExcel_Style_Border |
| * @throws PHPExcel_Exception |
| */ |
| public function getHorizontal() { |
| if (!$this->_isSupervisor) { |
| throw new PHPExcel_Exception('Can only get pseudo-border for supervisor.'); |
| } |
| return $this->_horizontal; |
| } |
| /** |
| * Get DiagonalDirection |
| * |
| * @return int |
| */ |
| public function getDiagonalDirection() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getDiagonalDirection(); |
| } |
| return $this->_diagonalDirection; |
| } |
| /** |
| * Set DiagonalDirection |
| * |
| * @param int $pValue |
| * @return PHPExcel_Style_Borders |
| */ |
| public function setDiagonalDirection($pValue = PHPExcel_Style_Borders::DIAGONAL_NONE) { |
| if ($pValue == '') { |
| $pValue = PHPExcel_Style_Borders::DIAGONAL_NONE; |
| } |
| if ($this->_isSupervisor) { |
| $styleArray = $this->getStyleArray(array('diagonaldirection' => $pValue)); |
| $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray); |
| } else { |
| $this->_diagonalDirection = $pValue; |
| } |
| return $this; |
| } |
| /** |
| * Get hash code |
| * |
| * @return string Hash code |
| */ |
| public function getHashCode() { |
| if ($this->_isSupervisor) { |
| return $this->getSharedComponent()->getHashcode(); |
| } |
| return md5( |
| $this->getLeft()->getHashCode() |
| . $this->getRight()->getHashCode() |
| . $this->getTop()->getHashCode() |
| . $this->getBottom()->getHashCode() |
| . $this->getDiagonal()->getHashCode() |
| . $this->getDiagonalDirection() |
| . __CLASS__ |
| ); |
| } |
| } |