forked from bruno/pabx-app
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
298 lines
13 KiB
298 lines
13 KiB
<?php |
|
|
|
/** |
|
* PHPExcel_Shared_Excel5 |
|
* |
|
* Copyright (c) 2006 - 2015 PHPExcel |
|
* |
|
* This library is free software; you can redistribute it and/or |
|
* modify it under the terms of the GNU Lesser General Public |
|
* License as published by the Free Software Foundation; either |
|
* version 2.1 of the License, or (at your option) any later version. |
|
* |
|
* This library is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
* Lesser General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU Lesser General Public |
|
* License along with this library; if not, write to the Free Software |
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
* |
|
* @category PHPExcel |
|
* @package PHPExcel_Shared |
|
* @copyright Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel) |
|
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
|
* @version ##VERSION##, ##DATE## |
|
*/ |
|
class PHPExcel_Shared_Excel5 |
|
{ |
|
/** |
|
* Get the width of a column in pixels. We use the relationship y = ceil(7x) where |
|
* x is the width in intrinsic Excel units (measuring width in number of normal characters) |
|
* This holds for Arial 10 |
|
* |
|
* @param PHPExcel_Worksheet $sheet The sheet |
|
* @param string $col The column |
|
* @return integer The width in pixels |
|
*/ |
|
public static function sizeCol($sheet, $col = 'A') |
|
{ |
|
// default font of the workbook |
|
$font = $sheet->getParent()->getDefaultStyle()->getFont(); |
|
|
|
$columnDimensions = $sheet->getColumnDimensions(); |
|
|
|
// first find the true column width in pixels (uncollapsed and unhidden) |
|
if (isset($columnDimensions[$col]) and $columnDimensions[$col]->getWidth() != -1) { |
|
// then we have column dimension with explicit width |
|
$columnDimension = $columnDimensions[$col]; |
|
$width = $columnDimension->getWidth(); |
|
$pixelWidth = PHPExcel_Shared_Drawing::cellDimensionToPixels($width, $font); |
|
} elseif ($sheet->getDefaultColumnDimension()->getWidth() != -1) { |
|
// then we have default column dimension with explicit width |
|
$defaultColumnDimension = $sheet->getDefaultColumnDimension(); |
|
$width = $defaultColumnDimension->getWidth(); |
|
$pixelWidth = PHPExcel_Shared_Drawing::cellDimensionToPixels($width, $font); |
|
} else { |
|
// we don't even have any default column dimension. Width depends on default font |
|
$pixelWidth = PHPExcel_Shared_Font::getDefaultColumnWidthByFont($font, true); |
|
} |
|
|
|
// now find the effective column width in pixels |
|
if (isset($columnDimensions[$col]) and !$columnDimensions[$col]->getVisible()) { |
|
$effectivePixelWidth = 0; |
|
} else { |
|
$effectivePixelWidth = $pixelWidth; |
|
} |
|
|
|
return $effectivePixelWidth; |
|
} |
|
|
|
/** |
|
* Convert the height of a cell from user's units to pixels. By interpolation |
|
* the relationship is: y = 4/3x. If the height hasn't been set by the user we |
|
* use the default value. If the row is hidden we use a value of zero. |
|
* |
|
* @param PHPExcel_Worksheet $sheet The sheet |
|
* @param integer $row The row index (1-based) |
|
* @return integer The width in pixels |
|
*/ |
|
public static function sizeRow($sheet, $row = 1) |
|
{ |
|
// default font of the workbook |
|
$font = $sheet->getParent()->getDefaultStyle()->getFont(); |
|
|
|
$rowDimensions = $sheet->getRowDimensions(); |
|
|
|
// first find the true row height in pixels (uncollapsed and unhidden) |
|
if (isset($rowDimensions[$row]) and $rowDimensions[$row]->getRowHeight() != -1) { |
|
// then we have a row dimension |
|
$rowDimension = $rowDimensions[$row]; |
|
$rowHeight = $rowDimension->getRowHeight(); |
|
$pixelRowHeight = (int) ceil(4 * $rowHeight / 3); // here we assume Arial 10 |
|
} elseif ($sheet->getDefaultRowDimension()->getRowHeight() != -1) { |
|
// then we have a default row dimension with explicit height |
|
$defaultRowDimension = $sheet->getDefaultRowDimension(); |
|
$rowHeight = $defaultRowDimension->getRowHeight(); |
|
$pixelRowHeight = PHPExcel_Shared_Drawing::pointsToPixels($rowHeight); |
|
} else { |
|
// we don't even have any default row dimension. Height depends on default font |
|
$pointRowHeight = PHPExcel_Shared_Font::getDefaultRowHeightByFont($font); |
|
$pixelRowHeight = PHPExcel_Shared_Font::fontSizeToPixels($pointRowHeight); |
|
} |
|
|
|
// now find the effective row height in pixels |
|
if (isset($rowDimensions[$row]) and !$rowDimensions[$row]->getVisible()) { |
|
$effectivePixelRowHeight = 0; |
|
} else { |
|
$effectivePixelRowHeight = $pixelRowHeight; |
|
} |
|
|
|
return $effectivePixelRowHeight; |
|
} |
|
|
|
/** |
|
* Get the horizontal distance in pixels between two anchors |
|
* The distanceX is found as sum of all the spanning columns widths minus correction for the two offsets |
|
* |
|
* @param PHPExcel_Worksheet $sheet |
|
* @param string $startColumn |
|
* @param integer $startOffsetX Offset within start cell measured in 1/1024 of the cell width |
|
* @param string $endColumn |
|
* @param integer $endOffsetX Offset within end cell measured in 1/1024 of the cell width |
|
* @return integer Horizontal measured in pixels |
|
*/ |
|
public static function getDistanceX(PHPExcel_Worksheet $sheet, $startColumn = 'A', $startOffsetX = 0, $endColumn = 'A', $endOffsetX = 0) |
|
{ |
|
$distanceX = 0; |
|
|
|
// add the widths of the spanning columns |
|
$startColumnIndex = PHPExcel_Cell::columnIndexFromString($startColumn) - 1; // 1-based |
|
$endColumnIndex = PHPExcel_Cell::columnIndexFromString($endColumn) - 1; // 1-based |
|
for ($i = $startColumnIndex; $i <= $endColumnIndex; ++$i) { |
|
$distanceX += self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($i)); |
|
} |
|
|
|
// correct for offsetX in startcell |
|
$distanceX -= (int) floor(self::sizeCol($sheet, $startColumn) * $startOffsetX / 1024); |
|
|
|
// correct for offsetX in endcell |
|
$distanceX -= (int) floor(self::sizeCol($sheet, $endColumn) * (1 - $endOffsetX / 1024)); |
|
|
|
return $distanceX; |
|
} |
|
|
|
/** |
|
* Get the vertical distance in pixels between two anchors |
|
* The distanceY is found as sum of all the spanning rows minus two offsets |
|
* |
|
* @param PHPExcel_Worksheet $sheet |
|
* @param integer $startRow (1-based) |
|
* @param integer $startOffsetY Offset within start cell measured in 1/256 of the cell height |
|
* @param integer $endRow (1-based) |
|
* @param integer $endOffsetY Offset within end cell measured in 1/256 of the cell height |
|
* @return integer Vertical distance measured in pixels |
|
*/ |
|
public static function getDistanceY(PHPExcel_Worksheet $sheet, $startRow = 1, $startOffsetY = 0, $endRow = 1, $endOffsetY = 0) |
|
{ |
|
$distanceY = 0; |
|
|
|
// add the widths of the spanning rows |
|
for ($row = $startRow; $row <= $endRow; ++$row) { |
|
$distanceY += self::sizeRow($sheet, $row); |
|
} |
|
|
|
// correct for offsetX in startcell |
|
$distanceY -= (int) floor(self::sizeRow($sheet, $startRow) * $startOffsetY / 256); |
|
|
|
// correct for offsetX in endcell |
|
$distanceY -= (int) floor(self::sizeRow($sheet, $endRow) * (1 - $endOffsetY / 256)); |
|
|
|
return $distanceY; |
|
} |
|
|
|
/** |
|
* Convert 1-cell anchor coordinates to 2-cell anchor coordinates |
|
* This function is ported from PEAR Spreadsheet_Writer_Excel with small modifications |
|
* |
|
* Calculate the vertices that define the position of the image as required by |
|
* the OBJ record. |
|
* |
|
* +------------+------------+ |
|
* | A | B | |
|
* +-----+------------+------------+ |
|
* | |(x1,y1) | | |
|
* | 1 |(A1)._______|______ | |
|
* | | | | | |
|
* | | | | | |
|
* +-----+----| BITMAP |-----+ |
|
* | | | | | |
|
* | 2 | |______________. | |
|
* | | | (B2)| |
|
* | | | (x2,y2)| |
|
* +---- +------------+------------+ |
|
* |
|
* Example of a bitmap that covers some of the area from cell A1 to cell B2. |
|
* |
|
* Based on the width and height of the bitmap we need to calculate 8 vars: |
|
* $col_start, $row_start, $col_end, $row_end, $x1, $y1, $x2, $y2. |
|
* The width and height of the cells are also variable and have to be taken into |
|
* account. |
|
* The values of $col_start and $row_start are passed in from the calling |
|
* function. The values of $col_end and $row_end are calculated by subtracting |
|
* the width and height of the bitmap from the width and height of the |
|
* underlying cells. |
|
* The vertices are expressed as a percentage of the underlying cell width as |
|
* follows (rhs values are in pixels): |
|
* |
|
* x1 = X / W *1024 |
|
* y1 = Y / H *256 |
|
* x2 = (X-1) / W *1024 |
|
* y2 = (Y-1) / H *256 |
|
* |
|
* Where: X is distance from the left side of the underlying cell |
|
* Y is distance from the top of the underlying cell |
|
* W is the width of the cell |
|
* H is the height of the cell |
|
* |
|
* @param PHPExcel_Worksheet $sheet |
|
* @param string $coordinates E.g. 'A1' |
|
* @param integer $offsetX Horizontal offset in pixels |
|
* @param integer $offsetY Vertical offset in pixels |
|
* @param integer $width Width in pixels |
|
* @param integer $height Height in pixels |
|
* @return array |
|
*/ |
|
public static function oneAnchor2twoAnchor($sheet, $coordinates, $offsetX, $offsetY, $width, $height) |
|
{ |
|
list($column, $row) = PHPExcel_Cell::coordinateFromString($coordinates); |
|
$col_start = PHPExcel_Cell::columnIndexFromString($column) - 1; |
|
$row_start = $row - 1; |
|
|
|
$x1 = $offsetX; |
|
$y1 = $offsetY; |
|
|
|
// Initialise end cell to the same as the start cell |
|
$col_end = $col_start; // Col containing lower right corner of object |
|
$row_end = $row_start; // Row containing bottom right corner of object |
|
|
|
// Zero the specified offset if greater than the cell dimensions |
|
if ($x1 >= self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_start))) { |
|
$x1 = 0; |
|
} |
|
if ($y1 >= self::sizeRow($sheet, $row_start + 1)) { |
|
$y1 = 0; |
|
} |
|
|
|
$width = $width + $x1 -1; |
|
$height = $height + $y1 -1; |
|
|
|
// Subtract the underlying cell widths to find the end cell of the image |
|
while ($width >= self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_end))) { |
|
$width -= self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_end)); |
|
++$col_end; |
|
} |
|
|
|
// Subtract the underlying cell heights to find the end cell of the image |
|
while ($height >= self::sizeRow($sheet, $row_end + 1)) { |
|
$height -= self::sizeRow($sheet, $row_end + 1); |
|
++$row_end; |
|
} |
|
|
|
// Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell |
|
// with zero height or width. |
|
if (self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_start)) == 0) { |
|
return; |
|
} |
|
if (self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_end)) == 0) { |
|
return; |
|
} |
|
if (self::sizeRow($sheet, $row_start + 1) == 0) { |
|
return; |
|
} |
|
if (self::sizeRow($sheet, $row_end + 1) == 0) { |
|
return; |
|
} |
|
|
|
// Convert the pixel values to the percentage value expected by Excel |
|
$x1 = $x1 / self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_start)) * 1024; |
|
$y1 = $y1 / self::sizeRow($sheet, $row_start + 1) * 256; |
|
$x2 = ($width + 1) / self::sizeCol($sheet, PHPExcel_Cell::stringFromColumnIndex($col_end)) * 1024; // Distance to right side of object |
|
$y2 = ($height + 1) / self::sizeRow($sheet, $row_end + 1) * 256; // Distance to bottom of object |
|
|
|
$startCoordinates = PHPExcel_Cell::stringFromColumnIndex($col_start) . ($row_start + 1); |
|
$endCoordinates = PHPExcel_Cell::stringFromColumnIndex($col_end) . ($row_end + 1); |
|
|
|
$twoAnchor = array( |
|
'startCoordinates' => $startCoordinates, |
|
'startOffsetX' => $x1, |
|
'startOffsetY' => $y1, |
|
'endCoordinates' => $endCoordinates, |
|
'endOffsetX' => $x2, |
|
'endOffsetY' => $y2, |
|
); |
|
|
|
return $twoAnchor; |
|
} |
|
}
|
|
|