/*

 * This file is part of the render object implementation for KHTML.

 *

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 *

 */

#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)

{

}

RenderInline::~RenderInline()

{

}

void RenderInline::setStyle(RenderStyle* newStyle)

{

    RenderFlow::setStyle(newStyle);

    setInline(true);

    // Ensure that all of the split inlines pick up the new style. We

    // only do this if we're an inline, since we don't want to propagate

    // a block's style to the other inlines.

    // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before

    // and after the block share the same style, but the block doesn't

    // need to pass its style on to anyone else.

    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;

    // Update pseudos for :before and :after now.

    if (!isAnonymous()) {

        updateBeforeAfterContent(RenderStyle::BEFORE);

        updateBeforeAfterContent(RenderStyle::AFTER);

    }

}

bool RenderInline::isInlineContinuation() const

{

    return m_isContinuation;

}

static inline bool isAfterContent(RenderObject* child)

{

    if (!child)

        return false;

    if (child->style()->styleType() != RenderStyle::AFTER)

        return false;

    // Text nodes don't have their own styles, so ignore the style on a text node.

    if (child->isText() && !child->isBR())

        return false;

    return true;

}

void RenderInline::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild)

{

    // Make sure we don't append things after :after-generated content if we have it.

    if (!beforeChild && isAfterContent(lastChild()))

        beforeChild = lastChild();

    if (!newChild->isInline() && !newChild->isFloatingOrPositioned()) {

        // We are placing a block inside an inline. We have to perform a split of this

        // inline into continuations.  This involves creating an anonymous block box to hold

        // |newChild|.  We then make that block box a continuation of this inline.  We take all of

        // the children after |beforeChild| and put them in a clone of this object.

        RenderStyle* newStyle = new (renderArena()) RenderStyle();

        newStyle->inheritFrom(style());

        newStyle->setDisplay(BLOCK);

        RenderBlock* newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);

        newBox->setStyle(newStyle);

        RenderFlow* oldContinuation = continuation();

        setContinuation(newBox);

        // Someone may have put a <p> inside a <q>, causing a split.  When this happens, the :after content

        // has to move into the inline continuation.  Call updateBeforeAfterContent to ensure that our :after

        // content gets properly destroyed.

        bool isLastChild = (beforeChild == lastChild());

        updateBeforeAfterContent(RenderStyle::AFTER);

        if (isLastChild && beforeChild != lastChild())

            beforeChild = 0; // We destroyed the last child, so now we need to update our insertion

                             // point to be 0.  It's just a straight append now.

        splitFlow(beforeChild, newBox, newChild, oldContinuation);

        return;

    }

    RenderContainer::addChild(newChild, beforeChild);

    newChild->setNeedsLayoutAndPrefWidthsRecalc();

}

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)

{

    // Create a clone of this inline.

    RenderInline* clone = cloneInline(this);

    clone->setContinuation(oldCont);

    // Now take all of the children from beforeChild to the end and remove

    // them from |this| and place them in the clone.

    RenderObject* o = beforeChild;

    while (o) {

        RenderObject* tmp = o;

        o = tmp->nextSibling();

        clone->addChildToFlow(removeChildNode(tmp), 0);

        tmp->setNeedsLayoutAndPrefWidthsRecalc();

    }

    // Hook |clone| up as the continuation of the middle block.

    middleBlock->setContinuation(clone);

    // We have been reparented and are now under the fromBlock.  We need

    // to walk up our inline parent chain until we hit the containing block.

    // Once we hit the containing block we're done.

    RenderFlow* curr = static_cast<RenderFlow*>(parent());

    RenderFlow* currChild = this;

    // FIXME: Because splitting is O(n^2) as tags nest pathologically, we cap the depth at which we're willing to clone.

    // There will eventually be a better approach to this problem that will let us nest to a much

    // greater depth (see bugzilla bug 13430) but for now we have a limit.  This *will* result in

    // incorrect rendering, but the alternative is to hang forever.

    unsigned splitDepth = 1;

    const unsigned cMaxSplitDepth = 200; 

    while (curr && curr != fromBlock) {

        if (splitDepth < cMaxSplitDepth) {

            // Create a new clone.

            RenderInline* cloneChild = clone;

            clone = cloneInline(curr);

            // Insert our child clone as the first child.

            clone->addChildToFlow(cloneChild, 0);

            // Hook the clone up as a continuation of |curr|.

            RenderFlow* oldCont = curr->continuation();

            curr->setContinuation(clone);

            clone->setContinuation(oldCont);

            // Someone may have indirectly caused a <q> to split.  When this happens, the :after content

            // has to move into the inline continuation.  Call updateBeforeAfterContent to ensure that the inline's :after

            // content gets properly destroyed.

            curr->updateBeforeAfterContent(RenderStyle::AFTER);

            // Now we need to take all of the children starting from the first child

            // *after* currChild and append them all to the clone.

            o = currChild->nextSibling();

            while (o) {

                RenderObject* tmp = o;

                o = tmp->nextSibling();

                clone->addChildToFlow(curr->removeChildNode(tmp), 0);

                tmp->setNeedsLayoutAndPrefWidthsRecalc();

            }

        }

        // Keep walking up the chain.

        currChild = curr;

        curr = static_cast<RenderFlow*>(curr->parent());

        splitDepth++;

    }

    // Now we are at the block level. We need to put the clone into the toBlock.

    toBlock->appendChildNode(clone);

    // Now take all the children after currChild and remove them from the fromBlock

    // and put them in the toBlock.

    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();

    // Delete our line boxes before we do the inline split into continuations.

    block->deleteLineBoxTree();

    bool madeNewBeforeBlock = false;

    if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {

        // We can reuse this block and make it the preBlock of the next continuation.

        pre = block;

        block = block->containingBlock();

    } else {

        // No anonymous block available for use.  Make one.

        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->setNeedsLayoutAndPrefWidthsRecalc();

        }

    }

    splitInlines(pre, post, newBlockBox, beforeChild, oldCont);

    // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting

    // time in makeChildrenNonInline by just setting this explicitly up front.

    newBlockBox->setChildrenInline(false);

    // We don't just call addChild, since it would pass things off to the

    // continuation, so we call addChildToFlow explicitly instead.  We delayed

    // adding the newChild until now so that the |newBlockBox| would be fully

    // connected, thus allowing newChild access to a renderArena should it need

    // to wrap itself in additional boxes (e.g., table construction).

    newBlockBox->addChildToFlow(newChild, 0);

    // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)

    // get deleted properly.  Because objects moves from the pre block into the post block, we want to

    // make new line boxes instead of leaving the old line boxes around.

    pre->setNeedsLayoutAndPrefWidthsRecalc();

    block->setNeedsLayoutAndPrefWidthsRecalc();

    post->setNeedsLayoutAndPrefWidthsRecalc();

}

void RenderInline::paint(PaintInfo& paintInfo, int tx, int ty)

{

    paintLines(paintInfo, tx, ty);

}

void RenderInline::absoluteRects(Vector<IntRect>& rects, int tx, int ty, bool topLevel)

{

    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(), false);

    }

    if (continuation() && topLevel)

        continuation()->absoluteRects(rects, 

                                      tx - containingBlock()->xPos() + continuation()->xPos(),

                                      ty - containingBlock()->yPos() + continuation()->yPos(),

                                      topLevel);

}

bool RenderInline::requiresLayer()

{

    return isRelPositioned() || style()->opacity() < 1.0f;

}

int RenderInline::width() const

{

    // Return the width of the minimal left side and the maximal right side.

    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

{

    // See <rdar://problem/5289721>, for an unknown reason the linked list here is sometimes inconsistent, first is non-zero and last is zero.  We have been

    // unable to reproduce this at all (and consequently unable to figure ot why this is happening).  The assert will hopefully catch the problem in debug

    // builds and help us someday figure out why.  We also put in a redundant check of lastLineBox() to avoid the crash for now.

    ASSERT(!firstLineBox() == !lastLineBox());  // Either both are null or both exist.

    if (firstLineBox() && lastLineBox())

        return lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();

    return 0;

}

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(const HitTestRequest& request, HitTestResult& result,

                                int x, int y, int tx, int ty, HitTestAction hitTestAction)

{

    return hitTestLines(request, result, x, y, tx, ty, hitTestAction);

}

VisiblePosition RenderInline::positionForCoordinates(int x, int y)

{

    // Translate the coords from the pre-anonymous block to the post-anonymous block.

    RenderBlock* cb = containingBlock();

    int parentBlockX = cb->xPos() + x;

    int parentBlockY = cb->yPos() + y;

    for (RenderObject* c = continuation(); c; c = c->continuation()) {

        RenderObject* contBlock = c;

        if (c->isInline())

            contBlock = c->containingBlock();

        if (c->isInline() || c->firstChild())

            return c->positionForCoordinates(parentBlockX - contBlock->xPos(), parentBlockY - contBlock->yPos());

    }

    return RenderFlow::positionForCoordinates(x, y);

}

} // namespace WebCore