Overview

Packages

  • JAMA
  • None
  • PHP
  • PHPExcel
    • CachedObjectStorage
    • Calculation
    • Cell
    • Chart
      • Renderer
    • Reader
      • Excel2007
      • Excel5
    • RichText
    • Settings
    • Shared
      • Escher
      • OLE
      • Trend
      • ZipArchive
    • Style
    • Worksheet
      • Drawing
    • Writer
      • 2007
      • CSV
      • Excel2007
      • Excel5
      • HTML
      • PDF

Classes

  • CholeskyDecomposition
  • Dao
  • DateTime
  • DateTimeZone
  • DOMNode
  • EigenvalueDecomposition
  • Elemento
  • Historial
  • Irradiacion
  • Latitud
  • MotorPhp
  • Panel
  • PclZip
  • Periodo
  • PHPExcel
  • PHPExcel_Autoloader
  • PHPExcel_Best_Fit
  • PHPExcel_CachedObjectStorage_APC
  • PHPExcel_CachedObjectStorage_CacheBase
  • PHPExcel_CachedObjectStorage_DiscISAM
  • PHPExcel_CachedObjectStorage_Igbinary
  • PHPExcel_CachedObjectStorage_Memcache
  • PHPExcel_CachedObjectStorage_Memory
  • PHPExcel_CachedObjectStorage_MemoryGZip
  • PHPExcel_CachedObjectStorage_MemorySerialized
  • PHPExcel_CachedObjectStorage_PHPTemp
  • PHPExcel_CachedObjectStorage_SQLite
  • PHPExcel_CachedObjectStorage_SQLite3
  • PHPExcel_CachedObjectStorage_Wincache
  • PHPExcel_CachedObjectStorageFactory
  • PHPExcel_CalcEngine_CyclicReferenceStack
  • PHPExcel_CalcEngine_Logger
  • PHPExcel_Calculation
  • PHPExcel_Calculation_Database
  • PHPExcel_Calculation_DateTime
  • PHPExcel_Calculation_Engineering
  • PHPExcel_Calculation_ExceptionHandler
  • PHPExcel_Calculation_Financial
  • PHPExcel_Calculation_FormulaParser
  • PHPExcel_Calculation_FormulaToken
  • PHPExcel_Calculation_Function
  • PHPExcel_Calculation_Functions
  • PHPExcel_Calculation_Logical
  • PHPExcel_Calculation_LookupRef
  • PHPExcel_Calculation_MathTrig
  • PHPExcel_Calculation_Statistical
  • PHPExcel_Calculation_TextData
  • PHPExcel_Calculation_Token_Stack
  • PHPExcel_Cell
  • PHPExcel_Cell_AdvancedValueBinder
  • PHPExcel_Cell_DataType
  • PHPExcel_Cell_DataValidation
  • PHPExcel_Cell_DefaultValueBinder
  • PHPExcel_Cell_Hyperlink
  • PHPExcel_Chart
  • PHPExcel_Chart_DataSeries
  • PHPExcel_Chart_DataSeriesValues
  • PHPExcel_Chart_Layout
  • PHPExcel_Chart_Legend
  • PHPExcel_Chart_PlotArea
  • PHPExcel_Chart_Renderer_jpgraph
  • PHPExcel_Chart_Title
  • PHPExcel_Comment
  • PHPExcel_DocumentProperties
  • PHPExcel_DocumentSecurity
  • PHPExcel_Exponential_Best_Fit
  • PHPExcel_HashTable
  • PHPExcel_IOFactory
  • PHPExcel_Linear_Best_Fit
  • PHPExcel_Logarithmic_Best_Fit
  • PHPExcel_NamedRange
  • PHPExcel_Polynomial_Best_Fit
  • PHPExcel_Power_Best_Fit
  • PHPExcel_Reader_Abstract
  • PHPExcel_Reader_CSV
  • PHPExcel_Reader_DefaultReadFilter
  • PHPExcel_Reader_Excel2003XML
  • PHPExcel_Reader_Excel2007
  • PHPExcel_Reader_Excel2007_Chart
  • PHPExcel_Reader_Excel2007_Theme
  • PHPExcel_Reader_Excel5
  • PHPExcel_Reader_Excel5_Escher
  • PHPExcel_Reader_Excel5_MD5
  • PHPExcel_Reader_Excel5_RC4
  • PHPExcel_Reader_Gnumeric
  • PHPExcel_Reader_HTML
  • PHPExcel_Reader_OOCalc
  • PHPExcel_Reader_SYLK
  • PHPExcel_ReferenceHelper
  • PHPExcel_RichText
  • PHPExcel_RichText_Run
  • PHPExcel_RichText_TextElement
  • PHPExcel_Settings
  • PHPExcel_Shared_CodePage
  • PHPExcel_Shared_Date
  • PHPExcel_Shared_Drawing
  • PHPExcel_Shared_Escher
  • PHPExcel_Shared_Escher_DgContainer
  • PHPExcel_Shared_Escher_DgContainer_SpgrContainer
  • PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer
  • PHPExcel_Shared_Escher_DggContainer
  • PHPExcel_Shared_Escher_DggContainer_BstoreContainer
  • PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE
  • PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip
  • PHPExcel_Shared_Excel5
  • PHPExcel_Shared_File
  • PHPExcel_Shared_Font
  • PHPExcel_Shared_JAMA_LUDecomposition
  • PHPExcel_Shared_JAMA_Matrix
  • PHPExcel_Shared_JAMA_QRDecomposition
  • PHPExcel_Shared_OLE
  • PHPExcel_Shared_OLE_ChainedBlockStream
  • PHPExcel_Shared_OLE_PPS
  • PHPExcel_Shared_OLE_PPS_File
  • PHPExcel_Shared_OLE_PPS_Root
  • PHPExcel_Shared_OLERead
  • PHPExcel_Shared_PasswordHasher
  • PHPExcel_Shared_String
  • PHPExcel_Shared_TimeZone
  • PHPExcel_Shared_XMLWriter
  • PHPExcel_Shared_ZipArchive
  • PHPExcel_Shared_ZipStreamWrapper
  • PHPExcel_Style
  • PHPExcel_Style_Alignment
  • PHPExcel_Style_Border
  • PHPExcel_Style_Borders
  • PHPExcel_Style_Color
  • PHPExcel_Style_Conditional
  • PHPExcel_Style_Fill
  • PHPExcel_Style_Font
  • PHPExcel_Style_NumberFormat
  • PHPExcel_Style_Protection
  • PHPExcel_Style_Supervisor
  • PHPExcel_Worksheet
  • PHPExcel_Worksheet_AutoFilter
  • PHPExcel_Worksheet_AutoFilter_Column
  • PHPExcel_Worksheet_AutoFilter_Column_Rule
  • PHPExcel_Worksheet_BaseDrawing
  • PHPExcel_Worksheet_CellIterator
  • PHPExcel_Worksheet_ColumnDimension
  • PHPExcel_Worksheet_Drawing
  • PHPExcel_Worksheet_Drawing_Shadow
  • PHPExcel_Worksheet_HeaderFooter
  • PHPExcel_Worksheet_HeaderFooterDrawing
  • PHPExcel_Worksheet_MemoryDrawing
  • PHPExcel_Worksheet_PageMargins
  • PHPExcel_Worksheet_PageSetup
  • PHPExcel_Worksheet_Protection
  • PHPExcel_Worksheet_Row
  • PHPExcel_Worksheet_RowDimension
  • PHPExcel_Worksheet_RowIterator
  • PHPExcel_Worksheet_SheetView
  • PHPExcel_WorksheetIterator
  • PHPExcel_Writer_Abstract
  • PHPExcel_Writer_CSV
  • PHPExcel_Writer_Excel2007
  • PHPExcel_Writer_Excel2007_Chart
  • PHPExcel_Writer_Excel2007_Comments
  • PHPExcel_Writer_Excel2007_ContentTypes
  • PHPExcel_Writer_Excel2007_DocProps
  • PHPExcel_Writer_Excel2007_Drawing
  • PHPExcel_Writer_Excel2007_Rels
  • PHPExcel_Writer_Excel2007_RelsRibbon
  • PHPExcel_Writer_Excel2007_RelsVBA
  • PHPExcel_Writer_Excel2007_StringTable
  • PHPExcel_Writer_Excel2007_Style
  • PHPExcel_Writer_Excel2007_Theme
  • PHPExcel_Writer_Excel2007_Workbook
  • PHPExcel_Writer_Excel2007_Worksheet
  • PHPExcel_Writer_Excel2007_WriterPart
  • PHPExcel_Writer_Excel5
  • PHPExcel_Writer_Excel5_BIFFwriter
  • PHPExcel_Writer_Excel5_Escher
  • PHPExcel_Writer_Excel5_Font
  • PHPExcel_Writer_Excel5_Parser
  • PHPExcel_Writer_Excel5_Workbook
  • PHPExcel_Writer_Excel5_Worksheet
  • PHPExcel_Writer_Excel5_Xf
  • PHPExcel_Writer_HTML
  • PHPExcel_Writer_PDF
  • PHPExcel_Writer_PDF_Core
  • PHPExcel_Writer_PDF_DomPDF
  • PHPExcel_Writer_PDF_mPDF
  • PHPExcel_Writer_PDF_tcPDF
  • Provincia
  • Radiacion
  • SingularValueDecomposition
  • Sistema
  • trendClass
  • xajax
  • xajaxArgumentManager
  • xajaxCallableObject
  • xajaxCallableObjectPlugin
  • xajaxControl
  • xajaxControlContainer
  • xajaxCustomRequest
  • xajaxCustomResponse
  • xajaxEvent
  • xajaxEventPlugin
  • xajaxFunctionPlugin
  • xajaxIncludeClientScriptPlugin
  • xajaxLanguageManager
  • xajaxPlugin
  • xajaxPluginManager
  • xajaxRequest
  • xajaxRequestPlugin
  • xajaxResponse
  • xajaxResponseManager
  • xajaxResponsePlugin
  • xajaxScriptPlugin
  • xajaxUserFunction
  • XMLWriter

Interfaces

  • DateTimeInterface
  • Iterator
  • PHPExcel_CachedObjectStorage_ICache
  • PHPExcel_Cell_IValueBinder
  • PHPExcel_IComparable
  • PHPExcel_Reader_IReader
  • PHPExcel_Reader_IReadFilter
  • PHPExcel_RichText_ITextElement
  • PHPExcel_Writer_IWriter
  • Throwable
  • Traversable

Exceptions

  • Exception
  • PHPExcel_Calculation_Exception
  • PHPExcel_Chart_Exception
  • PHPExcel_Exception
  • PHPExcel_Reader_Exception
  • PHPExcel_Writer_Exception

Functions

  • acosh
  • agregar_elemento
  • asinh
  • atanh
  • borrar_elementos
  • borrar_gdm_ab
  • borrar_irradiacion
  • borrar_latitud
  • borrar_panel
  • borrar_periodo
  • borrar_pmp_min_pmp_max
  • borrar_radiacion
  • borrar_resumen
  • borrar_sistema
  • borrar_sombra
  • gdm_ab
  • grabar_resumen
  • historial
  • hypo
  • irradiacion
  • JAMAError
  • latitud
  • limpiar_historial
  • login
  • mb_str_replace
  • mostrar_energia_total_ch
  • mostrar_panel_md_th
  • mostrar_panel_th
  • mostrar_radiacion_md_th
  • mostrar_radiacion_th
  • mostrar_resumen_th
  • panel
  • PclZipUtilCopyBlock
  • PclZipUtilOptionText
  • PclZipUtilPathInclusion
  • PclZipUtilPathReduction
  • PclZipUtilRename
  • PclZipUtilTranslateWinPath
  • periodo
  • pmp_min_pmp_max
  • preparar_panel
  • preparar_radiacion
  • preparar_radiacion_media
  • radiacion
  • resumen
  • sistema
  • sombra
  • xajaxCompressFile
  • xajaxErrorHandler
  • Overview
  • Package
  • Class
  • Tree
  • Deprecated
  • Todo
  • Download
  1: <?php
  2: /**
  3:  * PHPExcel
  4:  *
  5:  * Copyright (c) 2006 - 2014 PHPExcel
  6:  *
  7:  * This library is free software; you can redistribute it and/or
  8:  * modify it under the terms of the GNU Lesser General Public
  9:  * License as published by the Free Software Foundation; either
 10:  * version 2.1 of the License, or (at your option) any later version.
 11:  *
 12:  * This library is distributed in the hope that it will be useful,
 13:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 15:  * Lesser General Public License for more details.
 16:  *
 17:  * You should have received a copy of the GNU Lesser General Public
 18:  * License along with this library; if not, write to the Free Software
 19:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 20:  *
 21:  * @category   PHPExcel
 22:  * @package    PHPExcel_Style
 23:  * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 24:  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
 25:  * @version    1.8.0, 2014-03-02
 26:  */
 27: 
 28: 
 29: /**
 30:  * PHPExcel_Style
 31:  *
 32:  * @category   PHPExcel
 33:  * @package    PHPExcel_Style
 34:  * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 35:  */
 36: class PHPExcel_Style extends PHPExcel_Style_Supervisor implements PHPExcel_IComparable
 37: {
 38:     /**
 39:      * Font
 40:      *
 41:      * @var PHPExcel_Style_Font
 42:      */
 43:     protected $_font;
 44: 
 45:     /**
 46:      * Fill
 47:      *
 48:      * @var PHPExcel_Style_Fill
 49:      */
 50:     protected $_fill;
 51: 
 52:     /**
 53:      * Borders
 54:      *
 55:      * @var PHPExcel_Style_Borders
 56:      */
 57:     protected $_borders;
 58: 
 59:     /**
 60:      * Alignment
 61:      *
 62:      * @var PHPExcel_Style_Alignment
 63:      */
 64:     protected $_alignment;
 65: 
 66:     /**
 67:      * Number Format
 68:      *
 69:      * @var PHPExcel_Style_NumberFormat
 70:      */
 71:     protected $_numberFormat;
 72: 
 73:     /**
 74:      * Conditional styles
 75:      *
 76:      * @var PHPExcel_Style_Conditional[]
 77:      */
 78:     protected $_conditionalStyles;
 79: 
 80:     /**
 81:      * Protection
 82:      *
 83:      * @var PHPExcel_Style_Protection
 84:      */
 85:     protected $_protection;
 86: 
 87:     /**
 88:      * Index of style in collection. Only used for real style.
 89:      *
 90:      * @var int
 91:      */
 92:     protected $_index;
 93: 
 94:     /**
 95:      * Use Quote Prefix when displaying in cell editor. Only used for real style.
 96:      *
 97:      * @var boolean
 98:      */
 99:     protected $_quotePrefix = false;
100: 
101:     /**
102:      * Create a new PHPExcel_Style
103:      *
104:      * @param boolean $isSupervisor Flag indicating if this is a supervisor or not
105:      *      Leave this value at default unless you understand exactly what
106:      *    its ramifications are
107:      * @param boolean $isConditional Flag indicating if this is a conditional style or not
108:      *      Leave this value at default unless you understand exactly what
109:      *    its ramifications are
110:      */
111:     public function __construct($isSupervisor = false, $isConditional = false)
112:     {
113:         // Supervisor?
114:         $this->_isSupervisor = $isSupervisor;
115: 
116:         // Initialise values
117:         $this->_conditionalStyles   = array();
118:         $this->_font              = new PHPExcel_Style_Font($isSupervisor, $isConditional);
119:         $this->_fill              = new PHPExcel_Style_Fill($isSupervisor, $isConditional);
120:         $this->_borders           = new PHPExcel_Style_Borders($isSupervisor, $isConditional);
121:         $this->_alignment         = new PHPExcel_Style_Alignment($isSupervisor, $isConditional);
122:         $this->_numberFormat      = new PHPExcel_Style_NumberFormat($isSupervisor, $isConditional);
123:         $this->_protection        = new PHPExcel_Style_Protection($isSupervisor, $isConditional);
124: 
125:         // bind parent if we are a supervisor
126:         if ($isSupervisor) {
127:             $this->_font->bindParent($this);
128:             $this->_fill->bindParent($this);
129:             $this->_borders->bindParent($this);
130:             $this->_alignment->bindParent($this);
131:             $this->_numberFormat->bindParent($this);
132:             $this->_protection->bindParent($this);
133:         }
134:     }
135: 
136:     /**
137:      * Get the shared style component for the currently active cell in currently active sheet.
138:      * Only used for style supervisor
139:      *
140:      * @return PHPExcel_Style
141:      */
142:     public function getSharedComponent()
143:     {
144:         $activeSheet = $this->getActiveSheet();
145:         $selectedCell = $this->getActiveCell(); // e.g. 'A1'
146: 
147:         if ($activeSheet->cellExists($selectedCell)) {
148:             $xfIndex = $activeSheet->getCell($selectedCell)->getXfIndex();
149:         } else {
150:             $xfIndex = 0;
151:         }
152: 
153:         return $this->_parent->getCellXfByIndex($xfIndex);
154:     }
155: 
156:     /**
157:      * Get parent. Only used for style supervisor
158:      *
159:      * @return PHPExcel
160:      */
161:     public function getParent()
162:     {
163:         return $this->_parent;
164:     }
165: 
166:     /**
167:      * Build style array from subcomponents
168:      *
169:      * @param array $array
170:      * @return array
171:      */
172:     public function getStyleArray($array)
173:     {
174:         return array('quotePrefix' => $array);
175:     }
176: 
177:     /**
178:      * Apply styles from array
179:      *
180:      * <code>
181:      * $objPHPExcel->getActiveSheet()->getStyle('B2')->applyFromArray(
182:      *         array(
183:      *             'font'    => array(
184:      *                 'name'      => 'Arial',
185:      *                 'bold'      => true,
186:      *                 'italic'    => false,
187:      *                 'underline' => PHPExcel_Style_Font::UNDERLINE_DOUBLE,
188:      *                 'strike'    => false,
189:      *                 'color'     => array(
190:      *                     'rgb' => '808080'
191:      *                 )
192:      *             ),
193:      *             'borders' => array(
194:      *                 'bottom'     => array(
195:      *                     'style' => PHPExcel_Style_Border::BORDER_DASHDOT,
196:      *                     'color' => array(
197:      *                         'rgb' => '808080'
198:      *                     )
199:      *                 ),
200:      *                 'top'     => array(
201:      *                     'style' => PHPExcel_Style_Border::BORDER_DASHDOT,
202:      *                     'color' => array(
203:      *                         'rgb' => '808080'
204:      *                     )
205:      *                 )
206:      *             ),
207:      *             'quotePrefix'    => true
208:      *         )
209:      * );
210:      * </code>
211:      *
212:      * @param    array    $pStyles    Array containing style information
213:      * @param     boolean        $pAdvanced    Advanced mode for setting borders.
214:      * @throws    PHPExcel_Exception
215:      * @return PHPExcel_Style
216:      */
217:     public function applyFromArray($pStyles = null, $pAdvanced = true)
218:     {
219:         if (is_array($pStyles)) {
220:             if ($this->_isSupervisor) {
221: 
222:                 $pRange = $this->getSelectedCells();
223: 
224:                 // Uppercase coordinate
225:                 $pRange = strtoupper($pRange);
226: 
227:                 // Is it a cell range or a single cell?
228:                 if (strpos($pRange, ':') === false) {
229:                     $rangeA = $pRange;
230:                     $rangeB = $pRange;
231:                 } else {
232:                     list($rangeA, $rangeB) = explode(':', $pRange);
233:                 }
234: 
235:                 // Calculate range outer borders
236:                 $rangeStart = PHPExcel_Cell::coordinateFromString($rangeA);
237:                 $rangeEnd     = PHPExcel_Cell::coordinateFromString($rangeB);
238: 
239:                 // Translate column into index
240:                 $rangeStart[0]    = PHPExcel_Cell::columnIndexFromString($rangeStart[0]) - 1;
241:                 $rangeEnd[0]    = PHPExcel_Cell::columnIndexFromString($rangeEnd[0]) - 1;
242: 
243:                 // Make sure we can loop upwards on rows and columns
244:                 if ($rangeStart[0] > $rangeEnd[0] && $rangeStart[1] > $rangeEnd[1]) {
245:                     $tmp = $rangeStart;
246:                     $rangeStart = $rangeEnd;
247:                     $rangeEnd = $tmp;
248:                 }
249: 
250:                 // ADVANCED MODE:
251: 
252:                 if ($pAdvanced && isset($pStyles['borders'])) {
253: 
254:                     // 'allborders' is a shorthand property for 'outline' and 'inside' and
255:                     //        it applies to components that have not been set explicitly
256:                     if (isset($pStyles['borders']['allborders'])) {
257:                         foreach (array('outline', 'inside') as $component) {
258:                             if (!isset($pStyles['borders'][$component])) {
259:                                 $pStyles['borders'][$component] = $pStyles['borders']['allborders'];
260:                             }
261:                         }
262:                         unset($pStyles['borders']['allborders']); // not needed any more
263:                     }
264: 
265:                     // 'outline' is a shorthand property for 'top', 'right', 'bottom', 'left'
266:                     //        it applies to components that have not been set explicitly
267:                     if (isset($pStyles['borders']['outline'])) {
268:                         foreach (array('top', 'right', 'bottom', 'left') as $component) {
269:                             if (!isset($pStyles['borders'][$component])) {
270:                                 $pStyles['borders'][$component] = $pStyles['borders']['outline'];
271:                             }
272:                         }
273:                         unset($pStyles['borders']['outline']); // not needed any more
274:                     }
275: 
276:                     // 'inside' is a shorthand property for 'vertical' and 'horizontal'
277:                     //        it applies to components that have not been set explicitly
278:                     if (isset($pStyles['borders']['inside'])) {
279:                         foreach (array('vertical', 'horizontal') as $component) {
280:                             if (!isset($pStyles['borders'][$component])) {
281:                                 $pStyles['borders'][$component] = $pStyles['borders']['inside'];
282:                             }
283:                         }
284:                         unset($pStyles['borders']['inside']); // not needed any more
285:                     }
286: 
287:                     // width and height characteristics of selection, 1, 2, or 3 (for 3 or more)
288:                     $xMax = min($rangeEnd[0] - $rangeStart[0] + 1, 3);
289:                     $yMax = min($rangeEnd[1] - $rangeStart[1] + 1, 3);
290: 
291:                     // loop through up to 3 x 3 = 9 regions
292:                     for ($x = 1; $x <= $xMax; ++$x) {
293:                         // start column index for region
294:                         $colStart = ($x == 3) ?
295:                             PHPExcel_Cell::stringFromColumnIndex($rangeEnd[0])
296:                                 : PHPExcel_Cell::stringFromColumnIndex($rangeStart[0] + $x - 1);
297: 
298:                         // end column index for region
299:                         $colEnd = ($x == 1) ?
300:                             PHPExcel_Cell::stringFromColumnIndex($rangeStart[0])
301:                                 : PHPExcel_Cell::stringFromColumnIndex($rangeEnd[0] - $xMax + $x);
302: 
303:                         for ($y = 1; $y <= $yMax; ++$y) {
304: 
305:                             // which edges are touching the region
306:                             $edges = array();
307: 
308:                             // are we at left edge
309:                             if ($x == 1) {
310:                                 $edges[] = 'left';
311:                             }
312: 
313:                             // are we at right edge
314:                             if ($x == $xMax) {
315:                                 $edges[] = 'right';
316:                             }
317: 
318:                             // are we at top edge?
319:                             if ($y == 1) {
320:                                 $edges[] = 'top';
321:                             }
322: 
323:                             // are we at bottom edge?
324:                             if ($y == $yMax) {
325:                                 $edges[] = 'bottom';
326:                             }
327: 
328:                             // start row index for region
329:                             $rowStart = ($y == 3) ?
330:                                 $rangeEnd[1] : $rangeStart[1] + $y - 1;
331: 
332:                             // end row index for region
333:                             $rowEnd = ($y == 1) ?
334:                                 $rangeStart[1] : $rangeEnd[1] - $yMax + $y;
335: 
336:                             // build range for region
337:                             $range = $colStart . $rowStart . ':' . $colEnd . $rowEnd;
338: 
339:                             // retrieve relevant style array for region
340:                             $regionStyles = $pStyles;
341:                             unset($regionStyles['borders']['inside']);
342: 
343:                             // what are the inner edges of the region when looking at the selection
344:                             $innerEdges = array_diff( array('top', 'right', 'bottom', 'left'), $edges );
345: 
346:                             // inner edges that are not touching the region should take the 'inside' border properties if they have been set
347:                             foreach ($innerEdges as $innerEdge) {
348:                                 switch ($innerEdge) {
349:                                     case 'top':
350:                                     case 'bottom':
351:                                         // should pick up 'horizontal' border property if set
352:                                         if (isset($pStyles['borders']['horizontal'])) {
353:                                             $regionStyles['borders'][$innerEdge] = $pStyles['borders']['horizontal'];
354:                                         } else {
355:                                             unset($regionStyles['borders'][$innerEdge]);
356:                                         }
357:                                         break;
358:                                     case 'left':
359:                                     case 'right':
360:                                         // should pick up 'vertical' border property if set
361:                                         if (isset($pStyles['borders']['vertical'])) {
362:                                             $regionStyles['borders'][$innerEdge] = $pStyles['borders']['vertical'];
363:                                         } else {
364:                                             unset($regionStyles['borders'][$innerEdge]);
365:                                         }
366:                                         break;
367:                                 }
368:                             }
369: 
370:                             // apply region style to region by calling applyFromArray() in simple mode
371:                             $this->getActiveSheet()->getStyle($range)->applyFromArray($regionStyles, false);
372:                         }
373:                     }
374:                     return $this;
375:                 }
376: 
377:                 // SIMPLE MODE:
378: 
379:                 // Selection type, inspect
380:                 if (preg_match('/^[A-Z]+1:[A-Z]+1048576$/', $pRange)) {
381:                     $selectionType = 'COLUMN';
382:                 } else if (preg_match('/^A[0-9]+:XFD[0-9]+$/', $pRange)) {
383:                     $selectionType = 'ROW';
384:                 } else {
385:                     $selectionType = 'CELL';
386:                 }
387: 
388:                 // First loop through columns, rows, or cells to find out which styles are affected by this operation
389:                 switch ($selectionType) {
390:                     case 'COLUMN':
391:                         $oldXfIndexes = array();
392:                         for ($col = $rangeStart[0]; $col <= $rangeEnd[0]; ++$col) {
393:                             $oldXfIndexes[$this->getActiveSheet()->getColumnDimensionByColumn($col)->getXfIndex()] = true;
394:                         }
395:                         break;
396: 
397:                     case 'ROW':
398:                         $oldXfIndexes = array();
399:                         for ($row = $rangeStart[1]; $row <= $rangeEnd[1]; ++$row) {
400:                             if ($this->getActiveSheet()->getRowDimension($row)->getXfIndex() == null) {
401:                                 $oldXfIndexes[0] = true; // row without explicit style should be formatted based on default style
402:                             } else {
403:                                 $oldXfIndexes[$this->getActiveSheet()->getRowDimension($row)->getXfIndex()] = true;
404:                             }
405:                         }
406:                         break;
407: 
408:                     case 'CELL':
409:                         $oldXfIndexes = array();
410:                         for ($col = $rangeStart[0]; $col <= $rangeEnd[0]; ++$col) {
411:                             for ($row = $rangeStart[1]; $row <= $rangeEnd[1]; ++$row) {
412:                                 $oldXfIndexes[$this->getActiveSheet()->getCellByColumnAndRow($col, $row)->getXfIndex()] = true;
413:                             }
414:                         }
415:                         break;
416:                 }
417: 
418:                 // clone each of the affected styles, apply the style array, and add the new styles to the workbook
419:                 $workbook = $this->getActiveSheet()->getParent();
420:                 foreach ($oldXfIndexes as $oldXfIndex => $dummy) {
421:                     $style = $workbook->getCellXfByIndex($oldXfIndex);
422:                     $newStyle = clone $style;
423:                     $newStyle->applyFromArray($pStyles);
424: 
425:                     if ($existingStyle = $workbook->getCellXfByHashCode($newStyle->getHashCode())) {
426:                         // there is already such cell Xf in our collection
427:                         $newXfIndexes[$oldXfIndex] = $existingStyle->getIndex();
428:                     } else {
429:                         // we don't have such a cell Xf, need to add
430:                         $workbook->addCellXf($newStyle);
431:                         $newXfIndexes[$oldXfIndex] = $newStyle->getIndex();
432:                     }
433:                 }
434: 
435:                 // Loop through columns, rows, or cells again and update the XF index
436:                 switch ($selectionType) {
437:                     case 'COLUMN':
438:                         for ($col = $rangeStart[0]; $col <= $rangeEnd[0]; ++$col) {
439:                             $columnDimension = $this->getActiveSheet()->getColumnDimensionByColumn($col);
440:                             $oldXfIndex = $columnDimension->getXfIndex();
441:                             $columnDimension->setXfIndex($newXfIndexes[$oldXfIndex]);
442:                         }
443:                         break;
444: 
445:                     case 'ROW':
446:                         for ($row = $rangeStart[1]; $row <= $rangeEnd[1]; ++$row) {
447:                             $rowDimension = $this->getActiveSheet()->getRowDimension($row);
448:                             $oldXfIndex = $rowDimension->getXfIndex() === null ?
449:                                 0 : $rowDimension->getXfIndex(); // row without explicit style should be formatted based on default style
450:                             $rowDimension->setXfIndex($newXfIndexes[$oldXfIndex]);
451:                         }
452:                         break;
453: 
454:                     case 'CELL':
455:                         for ($col = $rangeStart[0]; $col <= $rangeEnd[0]; ++$col) {
456:                             for ($row = $rangeStart[1]; $row <= $rangeEnd[1]; ++$row) {
457:                                 $cell = $this->getActiveSheet()->getCellByColumnAndRow($col, $row);
458:                                 $oldXfIndex = $cell->getXfIndex();
459:                                 $cell->setXfIndex($newXfIndexes[$oldXfIndex]);
460:                             }
461:                         }
462:                         break;
463:                 }
464: 
465:             } else {
466:                 // not a supervisor, just apply the style array directly on style object
467:                 if (array_key_exists('fill', $pStyles)) {
468:                     $this->getFill()->applyFromArray($pStyles['fill']);
469:                 }
470:                 if (array_key_exists('font', $pStyles)) {
471:                     $this->getFont()->applyFromArray($pStyles['font']);
472:                 }
473:                 if (array_key_exists('borders', $pStyles)) {
474:                     $this->getBorders()->applyFromArray($pStyles['borders']);
475:                 }
476:                 if (array_key_exists('alignment', $pStyles)) {
477:                     $this->getAlignment()->applyFromArray($pStyles['alignment']);
478:                 }
479:                 if (array_key_exists('numberformat', $pStyles)) {
480:                     $this->getNumberFormat()->applyFromArray($pStyles['numberformat']);
481:                 }
482:                 if (array_key_exists('protection', $pStyles)) {
483:                     $this->getProtection()->applyFromArray($pStyles['protection']);
484:                 }
485:                 if (array_key_exists('quotePrefix', $pStyles)) {
486:                     $this->_quotePrefix = $pStyles['quotePrefix'];
487:                 }
488:             }
489:         } else {
490:             throw new PHPExcel_Exception("Invalid style array passed.");
491:         }
492:         return $this;
493:     }
494: 
495:     /**
496:      * Get Fill
497:      *
498:      * @return PHPExcel_Style_Fill
499:      */
500:     public function getFill()
501:     {
502:         return $this->_fill;
503:     }
504: 
505:     /**
506:      * Get Font
507:      *
508:      * @return PHPExcel_Style_Font
509:      */
510:     public function getFont()
511:     {
512:         return $this->_font;
513:     }
514: 
515:     /**
516:      * Set font
517:      *
518:      * @param PHPExcel_Style_Font $font
519:      * @return PHPExcel_Style
520:      */
521:     public function setFont(PHPExcel_Style_Font $font)
522:     {
523:         $this->_font = $font;
524:         return $this;
525:     }
526: 
527:     /**
528:      * Get Borders
529:      *
530:      * @return PHPExcel_Style_Borders
531:      */
532:     public function getBorders()
533:     {
534:         return $this->_borders;
535:     }
536: 
537:     /**
538:      * Get Alignment
539:      *
540:      * @return PHPExcel_Style_Alignment
541:      */
542:     public function getAlignment()
543:     {
544:         return $this->_alignment;
545:     }
546: 
547:     /**
548:      * Get Number Format
549:      *
550:      * @return PHPExcel_Style_NumberFormat
551:      */
552:     public function getNumberFormat()
553:     {
554:         return $this->_numberFormat;
555:     }
556: 
557:     /**
558:      * Get Conditional Styles. Only used on supervisor.
559:      *
560:      * @return PHPExcel_Style_Conditional[]
561:      */
562:     public function getConditionalStyles()
563:     {
564:         return $this->getActiveSheet()->getConditionalStyles($this->getActiveCell());
565:     }
566: 
567:     /**
568:      * Set Conditional Styles. Only used on supervisor.
569:      *
570:      * @param PHPExcel_Style_Conditional[] $pValue Array of condtional styles
571:      * @return PHPExcel_Style
572:      */
573:     public function setConditionalStyles($pValue = null)
574:     {
575:         if (is_array($pValue)) {
576:             $this->getActiveSheet()->setConditionalStyles($this->getSelectedCells(), $pValue);
577:         }
578:         return $this;
579:     }
580: 
581:     /**
582:      * Get Protection
583:      *
584:      * @return PHPExcel_Style_Protection
585:      */
586:     public function getProtection()
587:     {
588:         return $this->_protection;
589:     }
590: 
591:     /**
592:      * Get quote prefix
593:      *
594:      * @return boolean
595:      */
596:     public function getQuotePrefix()
597:     {
598:         if ($this->_isSupervisor) {
599:             return $this->getSharedComponent()->getQuotePrefix();
600:         }
601:         return $this->_quotePrefix;
602:     }
603: 
604:     /**
605:      * Set quote prefix
606:      *
607:      * @param boolean $pValue
608:      */
609:     public function setQuotePrefix($pValue)
610:     {
611:         if ($pValue == '') {
612:             $pValue = false;
613:         }
614:         if ($this->_isSupervisor) {
615:             $styleArray = array('quotePrefix' => $pValue);
616:             $this->getActiveSheet()->getStyle($this->getSelectedCells())->applyFromArray($styleArray);
617:         } else {
618:             $this->_quotePrefix = (boolean) $pValue;
619:         }
620:         return $this;
621:     }
622: 
623:     /**
624:      * Get hash code
625:      *
626:      * @return string Hash code
627:      */
628:     public function getHashCode()
629:     {
630:         $hashConditionals = '';
631:         foreach ($this->_conditionalStyles as $conditional) {
632:             $hashConditionals .= $conditional->getHashCode();
633:         }
634: 
635:         return md5(
636:               $this->_fill->getHashCode()
637:             . $this->_font->getHashCode()
638:             . $this->_borders->getHashCode()
639:             . $this->_alignment->getHashCode()
640:             . $this->_numberFormat->getHashCode()
641:             . $hashConditionals
642:             . $this->_protection->getHashCode()
643:             . ($this->_quotePrefix  ? 't' : 'f')
644:             . __CLASS__
645:         );
646:     }
647: 
648:     /**
649:      * Get own index in style collection
650:      *
651:      * @return int
652:      */
653:     public function getIndex()
654:     {
655:         return $this->_index;
656:     }
657: 
658:     /**
659:      * Set own index in style collection
660:      *
661:      * @param int $pValue
662:      */
663:     public function setIndex($pValue)
664:     {
665:         $this->_index = $pValue;
666:     }
667: 
668: }
669: 
Autene API documentation generated by ApiGen