/*

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

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

 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

 *

 * 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 "Chrome.h"

#include "FloatQuad.h"

#include "GraphicsContext.h"

#include "HitTestResult.h"

#include "Page.h"

#include "RenderArena.h"

#include "RenderBlock.h"

#include "RenderLayer.h"

#include "RenderView.h"

#include "TransformState.h"

#include "VisiblePosition.h"

#if ENABLE(DASHBOARD_SUPPORT)

#include "Frame.h"

#endif

using namespace std;

namespace WebCore {

RenderInline::RenderInline(Node* node)

    : RenderBoxModelObject(node)

    , m_continuation(0)

    , m_lineHeight(-1)

    , m_verticalPosition(PositionUndefined)

{

    setChildrenInline(true);

}

void RenderInline::destroy()

{

    // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will

    // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.

    children()->destroyLeftoverChildren();

    // Destroy our continuation before anything other than anonymous children.

    // The reason we don't destroy it before anonymous children is that they may

    // have continuations of their own that are anonymous children of our continuation.

    if (m_continuation) {

        m_continuation->destroy();

        m_continuation = 0;

    }

    if (!documentBeingDestroyed()) {

        if (firstLineBox()) {

            // We can't wait for RenderBoxModelObject::destroy to clear the selection,

            // because by then we will have nuked the line boxes.

            // FIXME: The SelectionController should be responsible for this when it

            // is notified of DOM mutations.

            if (isSelectionBorder())

                view()->clearSelection();

            // If line boxes are contained inside a root, that means we're an inline.

            // In that case, we need to remove all the line boxes so that the parent

            // lines aren't pointing to deleted children. If the first line box does

            // not have a parent that means they are either already disconnected or

            // root lines that can just be destroyed without disconnecting.

            if (firstLineBox()->parent()) {

                for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())

                    box->remove();

            }

        } else if (isInline() && parent())

            parent()->dirtyLinesFromChangedChild(this);

    }

    m_lineBoxes.deleteLineBoxes(renderArena());

    RenderBoxModelObject::destroy();

}

RenderInline* RenderInline::inlineElementContinuation() const

{

    if (!m_continuation || m_continuation->isInline())

        return toRenderInline(m_continuation);

    return toRenderBlock(m_continuation)->inlineElementContinuation();

}

void RenderInline::updateBoxModelInfoFromStyle()

{

    RenderBoxModelObject::updateBoxModelInfoFromStyle();

    setInline(true); // Needed for run-ins, since run-in is considered a block display type.

    // FIXME: Support transforms and reflections on inline flows someday.

    setHasTransform(false);

    setHasReflection(false);    

}

void RenderInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)

{

    RenderBoxModelObject::styleDidChange(diff, oldStyle);

    // 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.

    for (RenderInline* currCont = inlineElementContinuation(); currCont; currCont = currCont->inlineElementContinuation()) {

        RenderBoxModelObject* nextCont = currCont->continuation();

        currCont->setContinuation(0);

        currCont->setStyle(style());

        currCont->setContinuation(nextCont);

    }

    m_lineHeight = -1;

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

    if (!isAnonymous() && document()->usesBeforeAfterRules()) {

        children()->updateBeforeAfterContent(this, BEFORE);

        children()->updateBeforeAfterContent(this, AFTER);

    }

}

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

{

    if (continuation())

        return addChildToContinuation(newChild, beforeChild);

    return addChildIgnoringContinuation(newChild, beforeChild);

}

static RenderBoxModelObject* nextContinuation(RenderObject* renderer)

{

    if (renderer->isInline() && !renderer->isReplaced())

        return toRenderInline(renderer)->continuation();

    return toRenderBlock(renderer)->inlineElementContinuation();

}

RenderBoxModelObject* RenderInline::continuationBefore(RenderObject* beforeChild)

{

    if (beforeChild && beforeChild->parent() == this)

        return this;

    RenderBoxModelObject* curr = nextContinuation(this);

    RenderBoxModelObject* nextToLast = this;

    RenderBoxModelObject* last = this;

    while (curr) {

        if (beforeChild && beforeChild->parent() == curr) {

            if (curr->firstChild() == beforeChild)

                return last;

            return curr;

        }

        nextToLast = last;

        last = curr;

        curr = nextContinuation(curr);

    }

    if (!beforeChild && !last->firstChild())

        return nextToLast;

    return last;

}

void RenderInline::addChildIgnoringContinuation(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.

        RefPtr<RenderStyle> newStyle = RenderStyle::create();

        newStyle->inheritFrom(style());

        newStyle->setDisplay(BLOCK);

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

        newBox->setStyle(newStyle.release());

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

        if (document()->usesBeforeAfterRules())

            children()->updateBeforeAfterContent(this, 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;

    }

    RenderBoxModelObject::addChild(newChild, beforeChild);

    newChild->setNeedsLayoutAndPrefWidthsRecalc();

}

RenderInline* RenderInline::cloneInline(RenderInline* src)

{

    RenderInline* o = new (src->renderArena()) RenderInline(src->node());

    o->setStyle(src->style());

    return o;

}

void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,

                                RenderBlock* middleBlock,

                                RenderObject* beforeChild, RenderBoxModelObject* 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->addChildIgnoringContinuation(children()->removeChildNode(this, 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.

    RenderBoxModelObject* curr = toRenderBoxModelObject(parent());

    RenderBoxModelObject* 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) {

        ASSERT(curr->isRenderInline());

        if (splitDepth < cMaxSplitDepth) {

            // Create a new clone.

            RenderInline* cloneChild = clone;

            clone = cloneInline(toRenderInline(curr));

            // Insert our child clone as the first child.

            clone->addChildIgnoringContinuation(cloneChild, 0);

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

            RenderInline* inlineCurr = toRenderInline(curr);

            oldCont = inlineCurr->continuation();

            inlineCurr->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.

            if (document()->usesBeforeAfterRules())

                inlineCurr->children()->updateBeforeAfterContent(inlineCurr, 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->addChildIgnoringContinuation(inlineCurr->children()->removeChildNode(curr, tmp), 0);

                tmp->setNeedsLayoutAndPrefWidthsRecalc();

            }

        }

        // Keep walking up the chain.

        currChild = curr;

        curr = toRenderBoxModelObject(curr->parent());

        splitDepth++;

    }

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

    toBlock->children()->appendChildNode(toBlock, 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->children()->appendChildNode(toBlock, fromBlock->children()->removeChildNode(fromBlock, tmp));

    }

}

void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,

                             RenderObject* newChild, RenderBoxModelObject* 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;

        pre->removePositionedObjects(0);

        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->children()->insertChildNode(block, pre, boxFirst);

    block->children()->insertChildNode(block, newBlockBox, boxFirst);

    block->children()->insertChildNode(block, post, boxFirst);

    block->setChildrenInline(false);

    if (madeNewBeforeBlock) {

        RenderObject* o = boxFirst;

        while (o) {

            RenderObject* no = o;

            o = no->nextSibling();

            pre->children()->appendChildNode(pre, block->children()->removeChildNode(block, 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 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->addChild(newChild);

    // 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::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)

{

    RenderBoxModelObject* flow = continuationBefore(beforeChild);

    ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());

    RenderBoxModelObject* beforeChildParent = 0;

    if (beforeChild)

        beforeChildParent = toRenderBoxModelObject(beforeChild->parent());

    else {

        RenderBoxModelObject* cont = nextContinuation(flow);

        if (cont)

            beforeChildParent = cont;

        else

            beforeChildParent = flow;

    }

    if (newChild->isFloatingOrPositioned())

        return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

    // A continuation always consists of two potential candidates: an inline or an anonymous

    // block box holding block children.

    bool childInline = newChild->isInline();

    bool bcpInline = beforeChildParent->isInline();

    bool flowInline = flow->isInline();

    if (flow == beforeChildParent)

        return flow->addChildIgnoringContinuation(newChild, beforeChild);

    else {

        // The goal here is to match up if we can, so that we can coalesce and create the

        // minimal # of continuations needed for the inline.

        if (childInline == bcpInline)

            return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

        else if (flowInline == childInline)

            return flow->addChildIgnoringContinuation(newChild, 0); // Just treat like an append.

        else

            return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

    }

}

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

{

    m_lineBoxes.paint(this, paintInfo, tx, ty);

}

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

{

    if (InlineFlowBox* curr = firstLineBox()) {

        for (; curr; curr = curr->nextLineBox())

            rects.append(IntRect(tx + curr->x(), ty + curr->y(), curr->width(), curr->height()));

    } else

        rects.append(IntRect(tx, ty, 0, 0));

    if (continuation()) {

        if (continuation()->isBox()) {

            RenderBox* box = toRenderBox(continuation());

            continuation()->absoluteRects(rects, 

                                          tx - containingBlock()->x() + box->x(),

                                          ty - containingBlock()->y() + box->y());

        } else

            continuation()->absoluteRects(rects, tx - containingBlock()->x(), ty - containingBlock()->y());

    }

}

void RenderInline::absoluteQuads(Vector<FloatQuad>& quads)

{

    if (InlineFlowBox* curr = firstLineBox()) {

        for (; curr; curr = curr->nextLineBox()) {

            FloatRect localRect(curr->x(), curr->y(), curr->width(), curr->height());

            quads.append(localToAbsoluteQuad(localRect));

        }

    } else

        quads.append(localToAbsoluteQuad(FloatRect()));

    if (continuation())

        continuation()->absoluteQuads(quads);

}

int RenderInline::offsetLeft() const

{

    int x = RenderBoxModelObject::offsetLeft();

    if (firstLineBox())

        x += firstLineBox()->x();

    return x;

}

int RenderInline::offsetTop() const

{

    int y = RenderBoxModelObject::offsetTop();

    if (firstLineBox())

        y += firstLineBox()->y();

    return y;

}

int RenderInline::marginLeft() const

{

    Length margin = style()->marginLeft();

    if (margin.isAuto())

        return 0;

    if (margin.isFixed())

        return margin.value();

    if (margin.isPercent())

        return margin.calcMinValue(max(0, containingBlock()->availableWidth()));

    return 0;

}

int RenderInline::marginRight() const

{

    Length margin = style()->marginRight();

    if (margin.isAuto())

        return 0;

    if (margin.isFixed())

        return margin.value();

    if (margin.isPercent())

        return margin.calcMinValue(max(0, containingBlock()->availableWidth()));

    return 0;

}

const char* RenderInline::renderName() const

{

    if (isRelPositioned())

        return "RenderInline (relative positioned)";

    if (isAnonymous())

        return "RenderInline (generated)";

    if (isRunIn())

        return "RenderInline (run-in)";

    return "RenderInline";

}

bool RenderInline::nodeAtPoint(const HitTestRequest& request, HitTestResult& result,

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

{

    return m_lineBoxes.hitTest(this, request, result, x, y, tx, ty, hitTestAction);

}

VisiblePosition RenderInline::positionForPoint(const IntPoint& point)

{

    // FIXME: Does not deal with relative positioned inlines (should it?)

    RenderBlock* cb = containingBlock();

    if (firstLineBox()) {

        // This inline actually has a line box.  We must have clicked in the border/padding of one of these boxes.  We

        // should try to find a result by asking our containing block.

        return cb->positionForPoint(point);

    }

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

    int parentBlockX = cb->x() + point.x();

    int parentBlockY = cb->y() + point.y();

    RenderBoxModelObject* c = continuation();

    while (c) {

        RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);

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

            return c->positionForCoordinates(parentBlockX - contBlock->x(), parentBlockY - contBlock->y());

        c = toRenderBlock(c)->inlineElementContinuation();

    }

    return RenderBoxModelObject::positionForPoint(point);

}

IntRect RenderInline::linesBoundingBox() const

{

    IntRect result;