#include "config.h"
#include "RenderInline.h"
#include "Document.h"
#include "RenderArena.h"
#include "RenderBlock.h"
#include "VisiblePosition.h"
namespace WebCore {
RenderInline::RenderInline(Node* node)
:RenderFlow(node), m_isContinuation(false)
{}
RenderInline::~RenderInline()
{}
void RenderInline::setStyle(RenderStyle* _style)
{
RenderFlow::setStyle(_style);
setInline(true);
RenderFlow* currCont = continuation();
while (currCont) {
if (currCont->isInline()) {
RenderFlow* nextCont = currCont->continuation();
currCont->setContinuation(0);
currCont->setStyle(style());
currCont->setContinuation(nextCont);
}
currCont = currCont->continuation();
}
m_lineHeight = -1;
updatePseudoChild(RenderStyle::BEFORE);
updatePseudoChild(RenderStyle::AFTER);
}
bool RenderInline::isInlineContinuation() const
{
return m_isContinuation;
}
void RenderInline::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild)
{
if (!beforeChild && lastChild() && lastChild()->style()->styleType() == RenderStyle::AFTER)
beforeChild = lastChild();
if (!newChild->isInline() && !newChild->isFloatingOrPositioned() && containingBlock()->isBlockFlow()) {
RenderStyle *newStyle = new (renderArena()) RenderStyle();
newStyle->inheritFrom(style());
newStyle->setDisplay(BLOCK);
RenderBlock *newBox = new (renderArena()) RenderBlock(document() );
newBox->setStyle(newStyle);
RenderFlow* oldContinuation = continuation();
setContinuation(newBox);
bool isLastChild = (beforeChild == lastChild());
updatePseudoChild(RenderStyle::AFTER);
if (isLastChild && beforeChild != lastChild())
beforeChild = 0;
splitFlow(beforeChild, newBox, newChild, oldContinuation);
return;
}
RenderContainer::addChild(newChild,beforeChild);
newChild->setNeedsLayoutAndMinMaxRecalc();
}
RenderInline* RenderInline::cloneInline(RenderFlow* src)
{
RenderInline *o = new (src->renderArena()) RenderInline(src->element());
o->m_isContinuation = true;
o->setStyle(src->style());
return o;
}
void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
RenderBlock* middleBlock,
RenderObject* beforeChild, RenderFlow* oldCont)
{
RenderInline* clone = cloneInline(this);
clone->setContinuation(oldCont);
RenderObject* o = beforeChild;
while (o) {
RenderObject* tmp = o;
o = tmp->nextSibling();
clone->addChildToFlow(removeChildNode(tmp), 0);
tmp->setNeedsLayoutAndMinMaxRecalc();
}
middleBlock->setContinuation(clone);
RenderFlow* curr = static_cast<RenderFlow*>(parent());
RenderFlow* currChild = this;
while (curr && curr != fromBlock) {
RenderInline* cloneChild = clone;
clone = cloneInline(curr);
clone->addChildToFlow(cloneChild, 0);
RenderFlow* oldCont = curr->continuation();
curr->setContinuation(clone);
clone->setContinuation(oldCont);
curr->updatePseudoChild(RenderStyle::AFTER);
o = currChild->nextSibling();
while (o) {
RenderObject* tmp = o;
o = tmp->nextSibling();
clone->addChildToFlow(curr->removeChildNode(tmp), 0);
tmp->setNeedsLayoutAndMinMaxRecalc();
}
currChild = curr;
curr = static_cast<RenderFlow*>(curr->parent());
}
toBlock->appendChildNode(clone);
o = currChild->nextSibling();
while (o) {
RenderObject* tmp = o;
o = tmp->nextSibling();
toBlock->appendChildNode(fromBlock->removeChildNode(tmp));
}
}
void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
RenderObject* newChild, RenderFlow* oldCont)
{
RenderBlock* pre = 0;
RenderBlock* block = containingBlock();
bool madeNewBeforeBlock = false;
if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
pre = block;
block = block->containingBlock();
} else {
pre = block->createAnonymousBlock();
madeNewBeforeBlock = true;
}
RenderBlock* post = block->createAnonymousBlock();
RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
if (madeNewBeforeBlock)
block->insertChildNode(pre, boxFirst);
block->insertChildNode(newBlockBox, boxFirst);
block->insertChildNode(post, boxFirst);
block->setChildrenInline(false);
if (madeNewBeforeBlock) {
RenderObject* o = boxFirst;
while (o)
{
RenderObject* no = o;
o = no->nextSibling();
pre->appendChildNode(block->removeChildNode(no));
no->setNeedsLayoutAndMinMaxRecalc();
}
}
splitInlines(pre, post, newBlockBox, beforeChild, oldCont);
newBlockBox->setChildrenInline(false);
newBlockBox->addChildToFlow(newChild, 0);
pre->setNeedsLayoutAndMinMaxRecalc();
block->setNeedsLayoutAndMinMaxRecalc();
post->setNeedsLayoutAndMinMaxRecalc();
}
void RenderInline::paint(PaintInfo& i, int _tx, int _ty)
{
paintLines(i, _tx, _ty);
}
void RenderInline::absoluteRects(DeprecatedValueList<IntRect>& rects, int _tx, int _ty)
{
for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
rects.append(IntRect(_tx + curr->xPos(), _ty + curr->yPos(), curr->width(), curr->height()));
for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling())
if (!curr->isText())
curr->absoluteRects(rects, _tx + curr->xPos(), _ty + curr->yPos());
if (continuation())
continuation()->absoluteRects(rects,
_tx - containingBlock()->xPos() + continuation()->xPos(),
_ty - containingBlock()->yPos() + continuation()->yPos());
}
void RenderInline::calcMinMaxWidth()
{
ASSERT( !minMaxKnown() );
#ifdef DEBUG_LAYOUT
kdDebug( 6040 ) << renderName() << "(RenderInline)::calcMinMaxWidth() this=" << this << endl;
#endif
m_minWidth = 0;
m_maxWidth = 0;
setMinMaxKnown();
}
bool RenderInline::requiresLayer() {
return isRoot() || isRelPositioned() || style()->opacity() < 1.0f;
}
int RenderInline::width() const
{
int leftSide = 0;
int rightSide = 0;
for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
if (curr == firstLineBox() || curr->xPos() < leftSide)
leftSide = curr->xPos();
if (curr == firstLineBox() || curr->xPos() + curr->width() > rightSide)
rightSide = curr->xPos() + curr->width();
}
return rightSide - leftSide;
}
int RenderInline::height() const
{
int h = 0;
if (firstLineBox())
h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
return h;
}
int RenderInline::offsetLeft() const
{
int x = RenderFlow::offsetLeft();
if (firstLineBox())
x += firstLineBox()->xPos();
return x;
}
int RenderInline::offsetTop() const
{
int y = RenderFlow::offsetTop();
if (firstLineBox())
y += firstLineBox()->yPos();
return y;
}
const char *RenderInline::renderName() const
{
if (isRelPositioned())
return "RenderInline (relative positioned)";
if (isAnonymous())
return "RenderInline (generated)";
return "RenderInline";
}
bool RenderInline::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty,
HitTestAction hitTestAction)
{
return hitTestLines(info, _x, _y, _tx, _ty, hitTestAction);
}
VisiblePosition RenderInline::positionForCoordinates(int x, int y)
{
for (RenderObject *c = continuation(); c; c = c->continuation()) {
if (c->isInline() || c->firstChild())
return c->positionForCoordinates(x, y);
}
return RenderFlow::positionForCoordinates(x, y);
}
}