YetiForcePDF\Layout\TableBox::measureHeight()

Complexity

Conditions	33
Paths	> 20000

Size

Total Lines	134
Code Lines	98

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	0	Features	0

<?php
	public function measureHeight(bool $afterPageDividing = false)
	{
		if ($this->wasCut()) {
			return $this;
		}
		foreach ($this->getCells() as $cell) {
			$cell->measureHeight($afterPageDividing);
		}
		$style = $this->getStyle();
		$maxRowHeights = [];
		foreach ($this->getChildren() as $rowGroupIndex => $rowGroup) {
			$rows = $rowGroup->getChildren();
			$spannedRowsCount = []; // spannedRowsCount is array of number of row spans for each row
			foreach ($rows as $rowIndex => $row) {
				foreach ($row->getChildren() as $column) {
					$spannedRowsCount[$rowIndex] = max($spannedRowsCount[$rowIndex] ?? '0', $column->getRowSpan());
				}
			}
			$rowsCount = []; // rowsCount is array with number of rows they must share for each row
			foreach ($spannedRowsCount as $currentRowSpanIndex => $currentRowsCount) {
				for ($i = 0; $i < $currentRowsCount; ++$i) {
					$rowsCount[$currentRowSpanIndex + $i] = max($rowsCount[$currentRowSpanIndex + $i] ?? '0', $currentRowsCount);
				}
			}
			// get maximal height of each row
			foreach ($rows as $rowIndex => $row) {
				foreach ($row->getChildren() as $column) {
					$cell = $column->getFirstChild();
					if (!isset($maxRowHeights[$rowGroupIndex][$rowIndex])) {
						$maxRowHeights[$rowGroupIndex][$rowIndex] = '0';
					}
					$columnStyle = $column->getStyle();
					$columnVerticalSize = Math::add($columnStyle->getVerticalMarginsWidth(), $columnStyle->getVerticalPaddingsWidth(), $columnStyle->getVerticalBordersWidth());
					$columnHeight = Math::add($cell->getDimensions()->getOuterHeight(), $columnVerticalSize);
					// for now ignore height of column that have span greater than 1
					if (1 === $column->getRowSpan()) {
						$maxRowHeights[$rowGroupIndex][$rowIndex] = Math::max($maxRowHeights[$rowGroupIndex][$rowIndex], $columnHeight);
					}
				}
			}
			// column that is spanned with more than 1 row must have height that is equal to all spanned rows height
			foreach ($rows as $rowIndex => $row) {
				$currentRowMax = $maxRowHeights[$rowGroupIndex][$rowIndex] ?? '0';
				foreach ($row->getChildren() as $column) {
					$rowSpan = $column->getRowSpan();
					if ($rowSpan > 1) {
						$spannedRowsHeight = '0';
						// get sum of spanned row height starting from current row
						for ($i = 0; $i < $rowSpan; ++$i) {
							if (isset($maxRowHeights[$rowGroupIndex][$rowIndex + $i])) {
								$spannedRowsHeight = Math::add($spannedRowsHeight, $maxRowHeights[$rowGroupIndex][$rowIndex + $i]);
							}
						}
						$fromOtherRows = Math::div($spannedRowsHeight, (string) $rowSpan);
						$fromColumnHeight = Math::div($column->getDimensions()->getOuterHeight(), (string) $rowSpan);
						$currentRowMax = Math::max($currentRowMax, $fromOtherRows, $fromColumnHeight);
						// if column that have rowSpan >1 is higher than sum of all other spanned rows max height expand others
						if (Math::comp($fromColumnHeight, $fromOtherRows) > 0) {
							for ($i = 0; $i < $rowSpan; ++$i) {
								$maxRowHeights[$rowGroupIndex][$rowIndex + $i] = $currentRowMax;
							}
						}
					}
				}
				$maxRowHeights[$rowGroupIndex][$rowIndex] = $currentRowMax;
			}
		}
		$tableHeight = '0';
		$rowGroups = $this->getChildren();
		foreach ($rowGroups as $rowGroupIndex => $rowGroup) {
			$rowGroupHeight = '0';
			$rows = $rowGroup->getChildren();
			foreach ($rows as $rowIndex => $row) {
				$rowStyle = $row->getStyle();
				$row->getDimensions()->setHeight(Math::add($maxRowHeights[$rowGroupIndex][$rowIndex], $rowStyle->getVerticalBordersWidth(), $rowStyle->getVerticalPaddingsWidth()));
				$rowGroupHeight = Math::add($rowGroupHeight, $row->getDimensions()->getHeight());

It seems like $row->getDimensions()->getHeight() can also be of type null; however, parameter $numbers of YetiForcePDF\Math::add() does only seem to accept string, maybe add an additional type check?

				foreach ($row->getChildren() as $column) {
					if ($column->getRowSpan() > 1 && $afterPageDividing) {
						continue;
					}
					$column->getDimensions()->setHeight($row->getDimensions()->getInnerHeight());
					$cell = $column->getFirstChild();
					$cellStyle = $cell->getStyle();
					if ('auto' !== $cellStyle->getRules('height')) {
						$cellStyle->getRules()['height']->convert($cellStyle);
						$height = $cellStyle->getRules('height');
					} else {
						$height = $column->getDimensions()->getInnerHeight();
						$height = Math::div($height, (string) $column->getRowSpan());
					}
					$cellChildrenHeight = '0';
					foreach ($cell->getChildren() as $cellChild) {
						$cellChildrenHeight = Math::add($cellChildrenHeight, $cellChild->getDimensions()->getOuterHeight());
					}
					$cellVerticalSize = Math::add($cellStyle->getVerticalBordersWidth(), $cellStyle->getVerticalPaddingsWidth());
					$cellChildrenHeight = Math::add($cellChildrenHeight, $cellVerticalSize);
					$cellChildrenHeight = Math::div($cellChildrenHeight, (string) $column->getRowSpan());
					// add vertical padding if needed
					if (Math::comp($height, $cellChildrenHeight) > 0) {

It seems like $height can also be of type array; however, parameter $left of YetiForcePDF\Math::comp() does only seem to accept string, maybe add an additional type check?

						$freeSpace = Math::sub($height, $cellChildrenHeight);

It seems like $height can also be of type array; however, parameter $numbers of YetiForcePDF\Math::sub() does only seem to accept string, maybe add an additional type check?

						$cellStyle = $cell->getStyle();
						switch ($cellStyle->getRules('vertical-align')) {
							case 'top':
								$freeSpace = Math::add($freeSpace, $cellStyle->getRules('padding-bottom'));

It seems like $cellStyle->getRules('padding-bottom') can also be of type array; however, parameter $numbers of YetiForcePDF\Math::add() does only seem to accept string, maybe add an additional type check?

								$cellStyle->setRule('padding-bottom', $freeSpace);
								break;
							case 'bottom':
								$freeSpace = Math::add($freeSpace, $cellStyle->getRules('padding-top'));
								$cellStyle->setRule('padding-top', $freeSpace);
								break;
							case 'baseline':
							case 'middle':
							default:
								$disposition = Math::div($freeSpace, '2');
								$paddingTop = Math::add($cellStyle->getRules('padding-top'), $disposition);
								$paddingBottom = Math::add($cellStyle->getRules('padding-bottom'), $disposition);
								$cellStyle->setRule('padding-top', $paddingTop);
								$cellStyle->setRule('padding-bottom', $paddingBottom);
								break;
						}
					}
					$height = Math::max($height, $cellChildrenHeight);

It seems like $height can also be of type array; however, parameter $numbers of YetiForcePDF\Math::max() does only seem to accept string, maybe add an additional type check?

					$cell->getDimensions()->setHeight($height);
				}
			}
			if (isset($row) && 'separate' === $row->getStyle()->getRules('border-collapse')) {
				$rowGroupHeight = Math::add($rowGroupHeight, $row->getStyle()->getRules('border-spacing'));
			}
			$rowGroup->getDimensions()->setHeight($rowGroupHeight);
			$tableHeight = Math::add($tableHeight, $rowGroupHeight);
		}
		$this->getDimensions()->setHeight(Math::add($tableHeight, $style->getVerticalBordersWidth(), $style->getVerticalPaddingsWidth()));

		return $this;
	}