/**
* @test
*/
public function moveButNotResizeChildWithRightFloatOnResizing()
{
$width = 100;
$height = 100;
$this->node->setWidth($width);
$this->node->setHeight($height);
$boundary = $this->objectMother->getBoundaryStub(0, $height, $width, $height);
$this->invokeMethod($this->node, 'setBoundary', array($boundary));
$childWidth = 50;
$childHeight = 100;
$child = new Container(array('width' => $childWidth, 'height' => $childHeight, 'float' => 'right'));
$childBoundary = $this->objectMother->getBoundaryStub($width - $childWidth, $childHeight, $childWidth, $childHeight);
$this->invokeMethod($child, 'setBoundary', array($childBoundary));
$this->node->add($child);
$xResize = 20;
$this->node->resize($xResize, 0);
$expectedChildDiagonalXCoord = $width + $xResize;
$this->assertEquals($expectedChildDiagonalXCoord, $child->getDiagonalPoint()->getX());
$this->assertEquals($childWidth, $child->getWidth());
$xResize = -40;
$this->node->resize($xResize, 0);
$expectedChildDiagonalXCoord = $expectedChildDiagonalXCoord + $xResize;
$this->assertEquals($expectedChildDiagonalXCoord, $child->getDiagonalPoint()->getX());
$this->assertEquals($childWidth, $child->getWidth());
}
/**
* @test
*/
public function dontIgnorePaddingBottom()
{
$page = new Page();
$paddingBottom = 10;
$leftFloatedContainerHeight = 20;
$rightFloatedContainerHeight = 40;
$containerHeight = $paddingBottom + $leftFloatedContainerHeight + $rightFloatedContainerHeight;
$container = new Container();
$container->makeAttributesSnapshot();
$container->setPaddingBottom($paddingBottom);
$container->setHeight($containerHeight);
$container->setWidth($page->getWidth());
$this->invokeMethod($container, 'setBoundary', array($this->objectMother->getBoundaryStub(0, $page->getFirstPoint()->getY(), $page->getWidth(), $containerHeight)));
$leftFloatedContainer = new Container();
$leftFloatedContainer->setFloat(Node::FLOAT_LEFT);
$leftFloatedContainer->setHeight($leftFloatedContainerHeight);
$leftFloatedContainer->setWidth(10);
$this->invokeMethod($leftFloatedContainer, 'setBoundary', array($this->objectMother->getBoundaryStub(0, $page->getFirstPoint()->getY(), 10, $leftFloatedContainerHeight)));
$rightFloatedContainer = new Container();
$rightFloatedContainer->setFloat(Node::FLOAT_RIGHT);
$rightFloatedContainer->setHeight($rightFloatedContainerHeight);
$rightFloatedContainer->setWidth(10);
$this->invokeMethod($rightFloatedContainer, 'setBoundary', array($this->objectMother->getBoundaryStub(0, $page->getFirstPoint()->getY() + $leftFloatedContainerHeight, 10, $rightFloatedContainerHeight)));
$page->add($container->add($leftFloatedContainer)->add($rightFloatedContainer));
$this->formatter->format($container, $this->document);
$expectedHeight = $paddingBottom + $rightFloatedContainerHeight;
$this->assertEquals($expectedHeight, $container->getHeight());
$this->assertEquals($expectedHeight, $container->getFirstPoint()->getY() - $container->getDiagonalPoint()->getY());
}
private function createParagraph($x, $y, $width, $height)
{
$parent = new Container();
$parent->setWidth($width);
$paragraph = new Paragraph();
$parent->add($paragraph);
$boundary = $this->objectMother->getBoundaryStub($x, $y, $width, $height);
$this->invokeMethod($paragraph, 'setBoundary', array($boundary));
return $paragraph;
}
/**
* @test
* @dataProvider autoMarginConvertProvider
*/
public function autoMarginConvert($nodeWidth, $parentWidth, $expectedMarginLeft, $expectedMarginRight)
{
$node = new Container(array('width' => $nodeWidth));
$node->setWidth($nodeWidth);
$node->setMargin(0, 'auto');
$mock = $this->getMock('\\PHPPdf\\Core\\Node\\Page', array('getWidth', 'setWidth'));
$mock->expects($this->atLeastOnce())->method('getWidth')->will($this->returnValue($parentWidth));
if ($nodeWidth > $parentWidth) {
$mock->expects($this->once())->method('setWidth')->with($nodeWidth);
}
$mock->add($node);
$this->formatter->format($node, $this->document);
$this->assertEquals($expectedMarginLeft, $node->getMarginLeft());
$this->assertEquals($expectedMarginRight, $node->getMarginRight());
}
private function createContainers(array $heights, $parent = null)
{
$parent = $parent ? $parent : $this->column;
$width = 100;
$yStart = 0;
$containers = array();
foreach ($heights as $height) {
$container = new Container();
$container->setHeight($height);
$container->setWidth($width);
$parent->add($container);
$this->injectBoundary($container, $yStart);
$yStart += $height;
$containers[] = $container;
}
return $containers;
}
/**
* @test
*/
public function nodeFormatter()
{
$composeNode = new Container();
$composeNode->setWidth(140);
$children = array();
$children[] = $this->objectMother->getNodeStub(0, 500, 100, 200);
$children[] = $this->objectMother->getNodeStub(0, 300, 200, 200);
foreach ($children as $child) {
$composeNode->add($child);
}
$this->formatter->format($composeNode, $this->createDocumentStub());
$height = 0;
foreach ($children as $child) {
$height += $child->getHeight();
}
$this->assertEquals($height, $composeNode->getHeight());
$this->assertEquals(200, $composeNode->getWidth());
}
/**
* @test
*/
public function nodeWithAutoMarginPositioning()
{
$node = new Container(array('width' => 100, 'height' => 100));
$node->hadAutoMargins(true);
$node->makeAttributesSnapshot();
$node->setWidth(110);
$child = new Container(array('width' => 50, 'height' => 50));
$node->add($child);
$page = new Page();
$page->add($node);
$node->getBoundary()->setNext($page->getFirstPoint());
$child->getBoundary()->setNext($page->getFirstPoint());
foreach (array($node, $child) as $g) {
$this->formatter->format($g, $this->createDocumentStub());
}
$nodeBoundary = $node->getBoundary();
$childBoundary = $child->getBoundary();
$pageBoundary = $page->getBoundary();
$this->assertEquals($pageBoundary[0]->translate(-5, 0), $nodeBoundary[0]);
$this->assertEquals($pageBoundary[0]->translate(105, 0), $nodeBoundary[1]);
$this->assertEquals($pageBoundary[0]->translate(105, 100), $nodeBoundary[2]);
$this->assertEquals($pageBoundary[0]->translate(-5, 100), $nodeBoundary[3]);
}
public function setWatermark(Container $watermark)
{
$watermark->setParent($this);
$watermark->setAttribute('vertical-align', self::VERTICAL_ALIGN_MIDDLE);
$watermark->setHeight($this->getHeight());
$watermark->setWidth($this->getWidth());
$watermark->setBoundary(clone $this->getBoundary());
$this->watermark = $watermark;
}
private function setDimension(ColumnableContainer $columnableContainer, Container $container)
{
$container->setWidth($columnableContainer->getWidth());
$container->setHeight($columnableContainer->getHeight());
$this->setPointsToBoundary($columnableContainer->getBoundary(), $container->getBoundary());
}
/**
* _____________________________
* | |
* | ______________|
* |_____________| | <- breaking here
* | |
* |____________________________|
*
* @test
*/
public function breaking()
{
$x = 0;
$y = 500;
$width = 500;
$height = 500;
$firstPoint = Point::getInstance($x, $y);
$paragraphParent = new Container();
$paragraphParent->setWidth($width);
$paragraphParent->setHeight($height);
$paragraph = new Paragraph();
$paragraph->setParent($paragraphParent);
$text1 = new Text();
$text1->getBoundary()->setNext($firstPoint)->setNext($firstPoint->translate($width, 0))->setNext($firstPoint->translate($width, 200))->setNext($firstPoint->translate($width / 2, 200))->setNext($firstPoint->translate($width / 2, 250))->setNext($firstPoint->translate(0, 250))->close();
$text2 = new Text();
$text2->getBoundary()->setNext($firstPoint->translate($width / 2, 200))->setNext($firstPoint->translate($width, 200))->setNext($firstPoint->translate($width, 500))->setNext($firstPoint->translate(0, 500))->setNext($firstPoint->translate(0, 250))->setNext($firstPoint->translate($width / 2, 250))->close();
$text1->setWidth(500);
$text1->setHeight(250);
$text2->setWidth(500);
$text2->setHeight(300);
$text1->setAttribute('line-height', 100);
$text2->setAttribute('line-height', 100);
for ($i = 0; $i < 2; $i++) {
$line = new Line($paragraph, 0, $i * 100);
$part = new LinePart('', 500, 0, $text1);
$line->addPart($part);
$paragraph->addLine($line);
}
$line = new Line($paragraph, 0, 200);
$line->addPart(new LinePart('', $width / 2, 0, $text1));
$line->addPart(new LinePart('', $width / 2, 250, $text2));
$paragraph->addLine($line);
for ($i = 0; $i < 2; $i++) {
$line = new Line($paragraph, 0, ($i + 3) * 100);
$part = new LinePart('', 500, 0, $text2);
$line->addPart($part);
$paragraph->addLine($line);
}
$paragraph->add($text1);
$paragraph->add($text2);
$paragraph->getBoundary()->setNext($firstPoint)->setNext($firstPoint->translate($width, 0))->setNext($firstPoint->translate($width, 500))->setNext($firstPoint->translate(0, 500))->close();
$paragraph->setHeight(500);
$paragraphProduct = $paragraph->breakAt(225);
$this->assertEquals(200, $paragraph->getHeight());
$this->assertEquals(200, $paragraph->getFirstPoint()->getY() - $paragraph->getDiagonalPoint()->getY());
$this->assertEquals(300, $paragraphProduct->getHeight());
$this->assertEquals(300, $paragraphProduct->getFirstPoint()->getY() - $paragraphProduct->getDiagonalPoint()->getY());
$this->assertTrue($paragraphProduct !== null);
$this->assertEquals(200, $paragraph->getHeight());
$this->assertEquals(2, count($paragraph->getLines()));
$this->assertEquals(3, count($paragraphProduct->getLines()));
$this->assertEquals(1, count($paragraph->getChildren()));
$this->assertEquals(2, count($paragraphProduct->getChildren()));
foreach ($paragraphProduct->getLines() as $i => $line) {
$this->assertEquals($i * 100, $line->getYTranslation());
foreach ($line->getParts() as $part) {
// $this->assertTrue($part->getText() !== $text1);
// $this->assertTrue($part->getText() !== $text2);
}
}
}
