/*

 * Copyright (C) 2003, 2004, 2005, 2006, 2007 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 "InlineFlowBox.h"

#include "CachedImage.h"

#include "Document.h"

#include "EllipsisBox.h"

#include "GraphicsContext.h"

#include "InlineTextBox.h"

#include "HitTestResult.h"

#include "RootInlineBox.h"

#include "RenderBlock.h"

#include "RenderFlow.h"

#include "RenderListMarker.h"

#include "RenderTableCell.h"

#include "RootInlineBox.h"

#include "Text.h"

#include <math.h>

using namespace std;

namespace WebCore {

#ifndef NDEBUG

InlineFlowBox::~InlineFlowBox()

{

    if (!m_hasBadChildList)

        for (InlineBox* child = firstChild(); child; child = child->nextOnLine())

            child->setHasBadParent();

}

#endif

RenderFlow* InlineFlowBox::flowObject()

{

    return static_cast<RenderFlow*>(m_object);

}

int InlineFlowBox::marginLeft()

{

    if (!includeLeftEdge())

        return 0;

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

    if (margin.isAuto())

        return 0;

    if (margin.isFixed())

        return margin.value();

    return object()->marginLeft();

}

int InlineFlowBox::marginRight()

{

    if (!includeRightEdge())

        return 0;

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

    if (margin.isAuto())

        return 0;

    if (margin.isFixed())

        return margin.value();

    return object()->marginRight();

}

int InlineFlowBox::marginBorderPaddingLeft()

{

    return marginLeft() + borderLeft() + paddingLeft();

}

int InlineFlowBox::marginBorderPaddingRight()

{

    return marginRight() + borderRight() + paddingRight();

}

int InlineFlowBox::getFlowSpacingWidth()

{

    int totWidth = marginBorderPaddingLeft() + marginBorderPaddingRight();

    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {

        if (curr->isInlineFlowBox())

            totWidth += static_cast<InlineFlowBox*>(curr)->getFlowSpacingWidth();

    }

    return totWidth;

}

void InlineFlowBox::addToLine(InlineBox* child) 

{

    ASSERT(!child->parent());

    ASSERT(!child->nextOnLine());

    ASSERT(!child->prevOnLine());

    checkConsistency();

    child->setParent(this);

    if (!m_firstChild) {

        m_firstChild = child;

        m_lastChild = child;

    } else {

        m_lastChild->setNextOnLine(child);

        child->setPrevOnLine(m_lastChild);

        m_lastChild = child;

    }

    child->setFirstLineStyleBit(m_firstLine);

    if (child->isText())

        m_hasTextChildren = true;

    if (child->object()->selectionState() != RenderObject::SelectionNone)

        root()->setHasSelectedChildren(true);

    checkConsistency();

}

void InlineFlowBox::removeChild(InlineBox* child)

{

    checkConsistency();

    if (!m_dirty)

        dirtyLineBoxes();

    root()->childRemoved(child);

    if (child == m_firstChild)

        m_firstChild = child->nextOnLine();

    if (child == m_lastChild)

        m_lastChild = child->prevOnLine();

    if (child->nextOnLine())

        child->nextOnLine()->setPrevOnLine(child->prevOnLine());

    if (child->prevOnLine())

        child->prevOnLine()->setNextOnLine(child->nextOnLine());

    child->setParent(0);

    checkConsistency();

}

void InlineFlowBox::deleteLine(RenderArena* arena)

{

    InlineBox* child = firstChild();

    InlineBox* next = 0;

    while (child) {

        ASSERT(this == child->parent());

        next = child->nextOnLine();

#ifndef NDEBUG

        child->setParent(0);

#endif

        child->deleteLine(arena);

        child = next;

    }

#ifndef NDEBUG

    m_firstChild = 0;

    m_lastChild = 0;

#endif

    static_cast<RenderFlow*>(m_object)->removeLineBox(this);

    destroy(arena);

}

void InlineFlowBox::extractLine()

{

    if (!m_extracted)

        static_cast<RenderFlow*>(m_object)->extractLineBox(this);

    for (InlineBox* child = firstChild(); child; child = child->nextOnLine())

        child->extractLine();

}

void InlineFlowBox::attachLine()

{

    if (m_extracted)

        static_cast<RenderFlow*>(m_object)->attachLineBox(this);

    for (InlineBox* child = firstChild(); child; child = child->nextOnLine())

        child->attachLine();

}

void InlineFlowBox::adjustPosition(int dx, int dy)

{

    InlineRunBox::adjustPosition(dx, dy);

    for (InlineBox* child = firstChild(); child; child = child->nextOnLine())

        child->adjustPosition(dx, dy);

}

bool InlineFlowBox::onEndChain(RenderObject* endObject)

{

    if (!endObject)

        return false;

    if (endObject == object())

        return true;

    RenderObject* curr = endObject;

    RenderObject* parent = curr->parent();

    while (parent && !parent->isRenderBlock()) {

        if (parent->lastChild() != curr || parent == object())

            return false;

        curr = parent;

        parent = curr->parent();

    }

    return true;

}

void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, RenderObject* endObject)

{

    // All boxes start off open.  They will not apply any margins/border/padding on

    // any side.

    bool includeLeftEdge = false;

    bool includeRightEdge = false;

    RenderFlow* flow = static_cast<RenderFlow*>(object());

    if (!flow->firstChild())

        includeLeftEdge = includeRightEdge = true; // Empty inlines never split across lines.

    else if (parent()) { // The root inline box never has borders/margins/padding.

        bool ltr = flow->style()->direction() == LTR;

        // Check to see if all initial lines are unconstructed.  If so, then

        // we know the inline began on this line.

        if (!flow->firstLineBox()->isConstructed()) {

            if (ltr && flow->firstLineBox() == this)

                includeLeftEdge = true;

            else if (!ltr && flow->lastLineBox() == this)

                includeRightEdge = true;

        }

        // In order to determine if the inline ends on this line, we check three things:

        // (1) If we are the last line and we don't have a continuation(), then we can

        // close up.

        // (2) If the last line box for the flow has an object following it on the line (ltr,

        // reverse for rtl), then the inline has closed.

        // (3) The line may end on the inline.  If we are the last child (climbing up

        // the end object's chain), then we just closed as well.

        if (!flow->lastLineBox()->isConstructed()) {

            if (ltr) {

                if (!nextLineBox() &&

                    ((lastLine && !object()->continuation()) || nextOnLineExists() || onEndChain(endObject)))

                    includeRightEdge = true;

            } else {

                if ((!prevLineBox() || prevLineBox()->isConstructed()) &&

                    ((lastLine && !object()->continuation()) || prevOnLineExists() || onEndChain(endObject)))

                    includeLeftEdge = true;

            }

        }

    }

    setEdges(includeLeftEdge, includeRightEdge);

    // Recur into our children.

    for (InlineBox* currChild = firstChild(); currChild; currChild = currChild->nextOnLine()) {

        if (currChild->isInlineFlowBox()) {

            InlineFlowBox* currFlow = static_cast<InlineFlowBox*>(currChild);

            currFlow->determineSpacingForFlowBoxes(lastLine, endObject);

        }

    }

}

int InlineFlowBox::placeBoxesHorizontally(int x, int& leftPosition, int& rightPosition, bool& needsWordSpacing)

{

    // Set our x position.

    setXPos(x);

    int boxShadowLeft = 0;

    int boxShadowRight = 0;

    if (ShadowData* boxShadow = object()->style(m_firstLine)->boxShadow()) {

        boxShadowLeft = min(boxShadow->x - boxShadow->blur, 0);

        boxShadowRight = max(boxShadow->x + boxShadow->blur, 0);

    }

    leftPosition = min(x + boxShadowLeft, leftPosition);

    int startX = x;

    x += borderLeft() + paddingLeft();

    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {

        if (curr->object()->isText()) {

            InlineTextBox* text = static_cast<InlineTextBox*>(curr);

            RenderText* rt = static_cast<RenderText*>(text->object());

            if (rt->textLength()) {

                if (needsWordSpacing && DeprecatedChar(rt->characters()[text->start()]).isSpace())

                    x += rt->style(m_firstLine)->font().wordSpacing();

                needsWordSpacing = !DeprecatedChar(rt->characters()[text->end()]).isSpace();

            }

            text->setXPos(x);

            int strokeOverflow = static_cast<int>(ceilf(rt->style()->textStrokeWidth() / 2.0f));

            // If letter-spacing is negative, we should factor that into right overflow. (Even in RTL, letter-spacing is

            // applied to the right, so this is not an issue with left overflow.

            int letterSpacing = min(0, (int)rt->style(m_firstLine)->font().letterSpacing());

            int leftGlyphOverflow = -strokeOverflow;

            int rightGlyphOverflow = strokeOverflow - letterSpacing;

            int visualOverflowLeft = leftGlyphOverflow;

            int visualOverflowRight = rightGlyphOverflow;

            for (ShadowData* shadow = rt->style()->textShadow(); shadow; shadow = shadow->next) {

                visualOverflowLeft = min(visualOverflowLeft, shadow->x - shadow->blur + leftGlyphOverflow);

                visualOverflowRight = max(visualOverflowRight, shadow->x + shadow->blur + rightGlyphOverflow);

            }

            leftPosition = min(x + visualOverflowLeft, leftPosition);

            rightPosition = max(x + text->width() + visualOverflowRight, rightPosition);

            m_maxHorizontalVisualOverflow = max(max(visualOverflowRight, -visualOverflowLeft), m_maxHorizontalVisualOverflow);

            x += text->width();

        } else {

            if (curr->object()->isPositioned()) {

                if (curr->object()->parent()->style()->direction() == LTR)

                    curr->setXPos(x);

                else

                    // Our offset that we cache needs to be from the edge of the right border box and

                    // not the left border box.  We have to subtract |x| from the width of the block

                    // (which can be obtained from the root line box).

                    curr->setXPos(root()->object()->width()-x);

                continue; // The positioned object has no effect on the width.

            }

            if (curr->object()->isInlineFlow()) {

                InlineFlowBox* flow = static_cast<InlineFlowBox*>(curr);

                if (curr->object()->isCompact()) {

                    int ignoredX = x;

                    flow->placeBoxesHorizontally(ignoredX, leftPosition, rightPosition, needsWordSpacing);

                } else {

                    x += flow->marginLeft();

                    x = flow->placeBoxesHorizontally(x, leftPosition, rightPosition, needsWordSpacing);

                    x += flow->marginRight();

                }

            } else if (!curr->object()->isCompact() && (!curr->object()->isListMarker() || static_cast<RenderListMarker*>(curr->object())->isInside())) {

                x += curr->object()->marginLeft();

                curr->setXPos(x);

                leftPosition = min(x + curr->object()->overflowLeft(false), leftPosition);

                rightPosition = max(x + curr->object()->overflowWidth(false), rightPosition);

                x += curr->width() + curr->object()->marginRight();

            }

        }

    }

    x += borderRight() + paddingRight();

    setWidth(x - startX);

    rightPosition = max(xPos() + width() + boxShadowRight, rightPosition);

    return x;

}

void InlineFlowBox::verticallyAlignBoxes(int& heightOfBlock)

{

    int maxPositionTop = 0;

    int maxPositionBottom = 0;

    int maxAscent = 0;

    int maxDescent = 0;

    // Figure out if we're in strict mode.  Note that we can't simply use !style()->htmlHacks(),

    // because that would match almost strict mode as well.

    RenderObject* curr = object();

    while (curr && !curr->element())

        curr = curr->container();

    bool strictMode = (curr && curr->document()->inStrictMode());

    computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);

    if (maxAscent + maxDescent < max(maxPositionTop, maxPositionBottom))

        adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);

    int maxHeight = maxAscent + maxDescent;

    int topPosition = heightOfBlock;

    int bottomPosition = heightOfBlock;

    int selectionTop = heightOfBlock;

    int selectionBottom = heightOfBlock;

    placeBoxesVertically(heightOfBlock, maxHeight, maxAscent, strictMode, topPosition, bottomPosition, selectionTop, selectionBottom);

    setVerticalOverflowPositions(topPosition, bottomPosition);

    setVerticalSelectionPositions(selectionTop, selectionBottom);

    // Shrink boxes with no text children in quirks and almost strict mode.

    if (!strictMode)

        shrinkBoxesWithNoTextChildren(topPosition, bottomPosition);

    heightOfBlock += maxHeight;

}

void InlineFlowBox::adjustMaxAscentAndDescent(int& maxAscent, int& maxDescent,

                                              int maxPositionTop, int maxPositionBottom)

{

    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {

        // The computed lineheight needs to be extended for the

        // positioned elements

        if (curr->object()->isPositioned())

            continue; // Positioned placeholders don't affect calculations.

        if (curr->yPos() == PositionTop || curr->yPos() == PositionBottom) {

            if (curr->yPos() == PositionTop) {

                if (maxAscent + maxDescent < curr->height())

                    maxDescent = curr->height() - maxAscent;

            }

            else {

                if (maxAscent + maxDescent < curr->height())

                    maxAscent = curr->height() - maxDescent;

            }

            if (maxAscent + maxDescent >= max(maxPositionTop, maxPositionBottom))

                break;

        }

        if (curr->isInlineFlowBox())

            static_cast<InlineFlowBox*>(curr)->adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);

    }

}

void InlineFlowBox::computeLogicalBoxHeights(int& maxPositionTop, int& maxPositionBottom,

                                             int& maxAscent, int& maxDescent, bool strictMode)

{

    if (isRootInlineBox()) {

        // Examine our root box.

        setHeight(object()->lineHeight(m_firstLine, true));

        bool isTableCell = object()->isTableCell();

        if (isTableCell) {

            RenderTableCell* tableCell = static_cast<RenderTableCell*>(object());

            setBaseline(tableCell->RenderBlock::baselinePosition(m_firstLine, true));

        }

        else

            setBaseline(object()->baselinePosition(m_firstLine, true));

        if (hasTextChildren() || strictMode) {

            int ascent = baseline();

            int descent = height() - ascent;

            if (maxAscent < ascent)

                maxAscent = ascent;

            if (maxDescent < descent)

                maxDescent = descent;

        }

    }

    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {

        if (curr->object()->isPositioned())

            continue; // Positioned placeholders don't affect calculations.

        curr->setHeight(curr->object()->lineHeight(m_firstLine));

        curr->setBaseline(curr->object()->baselinePosition(m_firstLine));

        curr->setYPos(curr->object()->verticalPositionHint(m_firstLine));

        if (curr->yPos() == PositionTop) {

            if (maxPositionTop < curr->height())

                maxPositionTop = curr->height();

        }

        else if (curr->yPos() == PositionBottom) {

            if (maxPositionBottom < curr->height())

                maxPositionBottom = curr->height();

        }

        else if (curr->hasTextChildren() || strictMode) {

            int ascent = curr->baseline() - curr->yPos();

            int descent = curr->height() - ascent;

            if (maxAscent < ascent)

                maxAscent = ascent;

            if (maxDescent < descent)

                maxDescent = descent;

        }

        if (curr->isInlineFlowBox())

            static_cast<InlineFlowBox*>(curr)->computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);

    }

}

void InlineFlowBox::placeBoxesVertically(int y, int maxHeight, int maxAscent, bool strictMode,

                                         int& topPosition, int& bottomPosition, int& selectionTop, int& selectionBottom)

{

    if (isRootInlineBox())

        setYPos(y + maxAscent - baseline());// Place our root box.

    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {

        if (curr->object()->isPositioned())

            continue; // Positioned placeholders don't affect calculations.

        // Adjust boxes to use their real box y/height and not the logical height (as dictated by

        // line-height).

        if (curr->isInlineFlowBox())

            static_cast<InlineFlowBox*>(curr)->placeBoxesVertically(y, maxHeight, maxAscent, strictMode, topPosition, bottomPosition, selectionTop, selectionBottom);

        bool childAffectsTopBottomPos = true;

        if (curr->yPos() == PositionTop)

            curr->setYPos(y);

        else if (curr->yPos() == PositionBottom)

            curr->setYPos(y + maxHeight - curr->height());

        else {

            if (!curr->hasTextChildren() && !strictMode)

                childAffectsTopBottomPos = false;

            curr->setYPos(curr->yPos() + y + maxAscent - curr->baseline());

        }

        int newY = curr->yPos();

        int newHeight = curr->height();

        int newBaseline = curr->baseline();

        int overflowTop = 0;

        int overflowBottom = 0;

        if (curr->isText() || curr->isInlineFlowBox()) {

            const Font& font = curr->object()->style(m_firstLine)->font();

            newBaseline = font.ascent();

            newY += curr->baseline() - newBaseline;

            newHeight = newBaseline + font.descent();

            for (ShadowData* shadow = curr->object()->style()->textShadow(); shadow; shadow = shadow->next) {

                overflowTop = min(overflowTop, shadow->y - shadow->blur);

                overflowBottom = max(overflowBottom, shadow->y + shadow->blur);

            }

            if (ShadowData* boxShadow = curr->object()->style(m_firstLine)->boxShadow()) {

                overflowTop = min(overflowTop, boxShadow->y - boxShadow->blur);

                overflowBottom = max(overflowBottom, boxShadow->y + boxShadow->blur);

            }

            if (curr->isInlineFlowBox()) {

                newHeight += curr->object()->borderTop() + curr->object()->paddingTop() +

                            curr->object()->borderBottom() + curr->object()->paddingBottom();

                newY -= curr->object()->borderTop() + curr->object()->paddingTop();

                newBaseline += curr->object()->borderTop() + curr->object()->paddingTop();

            }

        } else if (!curr->object()->isBR()) {

            newY += curr->object()->marginTop();

            newHeight = curr->height() - (curr->object()->marginTop() + curr->object()->marginBottom());

            overflowTop = curr->object()->overflowTop(false);