/*

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

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

 *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)

 *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)

 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 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 "RenderBox.h"

#include "CachedImage.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Document.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HitTestResult.h"

#include "htmlediting.h"

#include "HTMLElement.h"

#include "HTMLNames.h"

#include "ImageBuffer.h"

#include "FloatQuad.h"

#include "Frame.h"

#include "Page.h"

#include "RenderArena.h"

#include "RenderFlexibleBox.h"

#include "RenderInline.h"

#include "RenderLayer.h"

#include "RenderTableCell.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "TransformState.h"

#include <algorithm>

#include <math.h>

#if ENABLE(WML)

#include "WMLNames.h"

#endif

using namespace std;

namespace WebCore {

using namespace HTMLNames;

// Used by flexible boxes when flexing this element.

typedef WTF::HashMap<const RenderBox*, int> OverrideSizeMap;

static OverrideSizeMap* gOverrideSizeMap = 0;

bool RenderBox::s_hadOverflowClip = false;

RenderBox::RenderBox(Node* node)

    : RenderBoxModelObject(node)

    , m_marginLeft(0)

    , m_marginRight(0)

    , m_marginTop(0)

    , m_marginBottom(0)

    , m_minPrefWidth(-1)

    , m_maxPrefWidth(-1)

    , m_inlineBoxWrapper(0)

{

    setIsBox();

}

RenderBox::~RenderBox()

{

}

void RenderBox::destroy()

{

    // A lot of the code in this function is just pasted into

    // RenderWidget::destroy. If anything in this function changes,

    // be sure to fix RenderWidget::destroy() as well.

    if (hasOverrideSize())

        gOverrideSizeMap->remove(this);

    if (style() && (style()->height().isPercent() || style()->minHeight().isPercent() || style()->maxHeight().isPercent()))

        RenderBlock::removePercentHeightDescendant(this);

    RenderBoxModelObject::destroy();

}

void RenderBox::removeFloatingOrPositionedChildFromBlockLists()

{

    ASSERT(isFloatingOrPositioned());

    if (documentBeingDestroyed())

        return;

    if (isFloating()) {

        RenderBlock* outermostBlock = containingBlock();

        for (RenderBlock* p = outermostBlock; p && !p->isRenderView(); p = p->containingBlock()) {

            if (p->containsFloat(this))

                outermostBlock = p;

        }

        if (outermostBlock)

            outermostBlock->markAllDescendantsWithFloatsForLayout(this, false);

    }

    if (isPositioned()) {

        RenderObject* p;

        for (p = parent(); p; p = p->parent()) {

            if (p->isRenderBlock())

                toRenderBlock(p)->removePositionedObject(this);

        }

    }

}

void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)

{

    s_hadOverflowClip = hasOverflowClip();

    if (style()) {

        // The background of the root element or the body element could propagate up to

        // the canvas.  Just dirty the entire canvas when our style changes substantially.

        if (diff >= StyleDifferenceRepaint && node() &&

                (node()->hasTagName(htmlTag) || node()->hasTagName(bodyTag)))

            view()->repaint();

        // When a layout hint happens and an object's position style changes, we have to do a layout

        // to dirty the render tree using the old position value now.

        if (diff == StyleDifferenceLayout && parent() && style()->position() != newStyle->position()) {

            markContainingBlocksForLayout();

            if (style()->position() == StaticPosition)

                repaint();

            else if (newStyle->position() == AbsolutePosition || newStyle->position() == FixedPosition)

                parent()->setChildNeedsLayout(true);

            if (isFloating() && !isPositioned() && (newStyle->position() == AbsolutePosition || newStyle->position() == FixedPosition))

                removeFloatingOrPositionedChildFromBlockLists();

        }

    } else if (newStyle && isBody())

        view()->repaint();

    if (FrameView *frameView = view()->frameView()) {

        bool newStyleIsFixed = newStyle && newStyle->position() == FixedPosition;

        bool oldStyleIsFixed = style() && style()->position() == FixedPosition;

        if (newStyleIsFixed != oldStyleIsFixed) {

            if (newStyleIsFixed)

                frameView->addFixedObject();

            else

                frameView->removeFixedObject();

        }

    }

    RenderBoxModelObject::styleWillChange(diff, newStyle);

}

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

{

    RenderBoxModelObject::styleDidChange(diff, oldStyle);

    if (needsLayout() && oldStyle && (oldStyle->height().isPercent() || oldStyle->minHeight().isPercent() || oldStyle->maxHeight().isPercent()))

        RenderBlock::removePercentHeightDescendant(this);

    // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the

    // new zoomed coordinate space.

    if (hasOverflowClip() && oldStyle && style() && oldStyle->effectiveZoom() != style()->effectiveZoom()) {

        int left = scrollLeft();

        if (left) {

            left = (left / oldStyle->effectiveZoom()) * style()->effectiveZoom();

            setScrollLeft(left);

        }

        int top = scrollTop();

        if (top) {

            top = (top / oldStyle->effectiveZoom()) * style()->effectiveZoom();

            setScrollTop(top);

        }

    }

    // Set the text color if we're the body.

    if (isBody())

        document()->setTextColor(style()->visitedDependentColor(CSSPropertyColor));

}

void RenderBox::updateBoxModelInfoFromStyle()

{

    RenderBoxModelObject::updateBoxModelInfoFromStyle();

    bool isRootObject = isRoot();

    bool isViewObject = isRenderView();

    // The root and the RenderView always paint their backgrounds/borders.

    if (isRootObject || isViewObject)

        setHasBoxDecorations(true);

    setPositioned(style()->position() == AbsolutePosition || style()->position() == FixedPosition);

    setFloating(!isPositioned() && style()->isFloating());

    // We also handle <body> and <html>, whose overflow applies to the viewport.

    if (style()->overflowX() != OVISIBLE && !isRootObject && (isRenderBlock() || isTableRow() || isTableSection())) {

        bool boxHasOverflowClip = true;

        if (isBody()) {

            // Overflow on the body can propagate to the viewport under the following conditions.

            // (1) The root element is <html>.

            // (2) We are the primary <body> (can be checked by looking at document.body).

            // (3) The root element has visible overflow.

            if (document()->documentElement()->hasTagName(htmlTag) &&

                document()->body() == node() &&

                document()->documentElement()->renderer()->style()->overflowX() == OVISIBLE)

                boxHasOverflowClip = false;

        }

        // Check for overflow clip.

        // It's sufficient to just check one direction, since it's illegal to have visible on only one overflow value.

        if (boxHasOverflowClip) {

            if (!s_hadOverflowClip)

                // Erase the overflow

                repaint();

            setHasOverflowClip();

        }

    }

    setHasTransform(style()->hasTransformRelatedProperty());

    setHasReflection(style()->boxReflect());

}

void RenderBox::layout()

{

    ASSERT(needsLayout());

    RenderObject* child = firstChild();

    if (!child) {

        setNeedsLayout(false);

        return;

    }

    LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()));

    while (child) {

        child->layoutIfNeeded();

        ASSERT(!child->needsLayout());

        child = child->nextSibling();

    }

    statePusher.pop();

    setNeedsLayout(false);

}

// More IE extensions.  clientWidth and clientHeight represent the interior of an object

// excluding border and scrollbar.

int RenderBox::clientWidth() const

{

    return width() - borderLeft() - borderRight() - verticalScrollbarWidth();

}

int RenderBox::clientHeight() const

{

    return height() - borderTop() - borderBottom() - horizontalScrollbarHeight();

}

int RenderBox::scrollWidth() const

{

    if (hasOverflowClip())

        return layer()->scrollWidth();

    // For objects with visible overflow, this matches IE.

    if (style()->direction() == LTR)

        return max(clientWidth(), rightmostPosition(true, false) - borderLeft());

    return clientWidth() - min(0, leftmostPosition(true, false) - borderLeft());

}

int RenderBox::scrollHeight() const

{

    if (hasOverflowClip())

        return layer()->scrollHeight();

    // For objects with visible overflow, this matches IE.

    return max(clientHeight(), lowestPosition(true, false) - borderTop());

}

int RenderBox::scrollLeft() const

{

    return hasOverflowClip() ? layer()->scrollXOffset() : 0;

}

int RenderBox::scrollTop() const

{

    return hasOverflowClip() ? layer()->scrollYOffset() : 0;

}

void RenderBox::setScrollLeft(int newLeft)

{

    if (hasOverflowClip())

        layer()->scrollToXOffset(newLeft);

}

void RenderBox::setScrollTop(int newTop)

{

    if (hasOverflowClip())

        layer()->scrollToYOffset(newTop);

}

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

{

    rects.append(IntRect(tx, ty, width(), height()));

}

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

{

    quads.append(localToAbsoluteQuad(FloatRect(0, 0, width(), height())));

}

IntRect RenderBox::absoluteContentBox() const

{

    IntRect rect = contentBoxRect();

    FloatPoint absPos = localToAbsolute(FloatPoint());

    rect.move(absPos.x(), absPos.y());

    return rect;

}

FloatQuad RenderBox::absoluteContentQuad() const

{

    IntRect rect = contentBoxRect();

    return localToAbsoluteQuad(FloatRect(rect));

}

IntRect RenderBox::outlineBoundsForRepaint(RenderBoxModelObject* repaintContainer, IntPoint* cachedOffsetToRepaintContainer) const

{

    IntRect box = borderBoundingBox();

    adjustRectForOutlineAndShadow(box);

    FloatQuad containerRelativeQuad = FloatRect(box);

    if (cachedOffsetToRepaintContainer)

        containerRelativeQuad.move(cachedOffsetToRepaintContainer->x(), cachedOffsetToRepaintContainer->y());

    else

        containerRelativeQuad = localToContainerQuad(containerRelativeQuad, repaintContainer);

    box = containerRelativeQuad.enclosingBoundingBox();

    // FIXME: layoutDelta needs to be applied in parts before/after transforms and

    // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308

    box.move(view()->layoutDelta());

    return box;

}

void RenderBox::addFocusRingRects(Vector<IntRect>& rects, int tx, int ty)

{

    if (width() && height())

        rects.append(IntRect(tx, ty, width(), height()));

}

IntRect RenderBox::reflectionBox() const

{

    IntRect result;

    if (!style()->boxReflect())

        return result;

    IntRect box = borderBoxRect();

    result = box;

    switch (style()->boxReflect()->direction()) {

        case ReflectionBelow:

            result.move(0, box.height() + reflectionOffset());

            break;

        case ReflectionAbove:

            result.move(0, -box.height() - reflectionOffset());

            break;

        case ReflectionLeft:

            result.move(-box.width() - reflectionOffset(), 0);

            break;

        case ReflectionRight:

            result.move(box.width() + reflectionOffset(), 0);

            break;

    }

    return result;

}

int RenderBox::reflectionOffset() const

{

    if (!style()->boxReflect())

        return 0;

    if (style()->boxReflect()->direction() == ReflectionLeft || style()->boxReflect()->direction() == ReflectionRight)

        return style()->boxReflect()->offset().calcValue(borderBoxRect().width());

    return style()->boxReflect()->offset().calcValue(borderBoxRect().height());

}

IntRect RenderBox::reflectedRect(const IntRect& r) const

{

    if (!style()->boxReflect())

        return IntRect();

    IntRect box = borderBoxRect();

    IntRect result = r;

    switch (style()->boxReflect()->direction()) {

        case ReflectionBelow:

            result.setY(box.bottom() + reflectionOffset() + (box.bottom() - r.bottom()));

            break;

        case ReflectionAbove:

            result.setY(box.y() - reflectionOffset() - box.height() + (box.bottom() - r.bottom()));

            break;

        case ReflectionLeft:

            result.setX(box.x() - reflectionOffset() - box.width() + (box.right() - r.right()));

            break;

        case ReflectionRight:

            result.setX(box.right() + reflectionOffset() + (box.right() - r.right()));

            break;

    }

    return result;

}

int RenderBox::verticalScrollbarWidth() const

{

    return includeVerticalScrollbarSize() ? layer()->verticalScrollbarWidth() : 0;

}

int RenderBox::horizontalScrollbarHeight() const

{

    return includeHorizontalScrollbarSize() ? layer()->horizontalScrollbarHeight() : 0;

}

bool RenderBox::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier, Node** stopNode)

{

    RenderLayer* l = layer();

    if (l && l->scroll(direction, granularity, multiplier)) {

        if (stopNode)

            *stopNode = node();

        return true;

    }

    if (stopNode && *stopNode && *stopNode == node())

        return true;

    RenderBlock* b = containingBlock();

    if (b && !b->isRenderView())

        return b->scroll(direction, granularity, multiplier, stopNode);

    return false;

}

bool RenderBox::canBeScrolledAndHasScrollableArea() const

{

    return canBeProgramaticallyScrolled(false) && (scrollHeight() != clientHeight() || scrollWidth() != clientWidth());

}

bool RenderBox::canBeProgramaticallyScrolled(bool) const

{

    return (hasOverflowClip() && (scrollsOverflow() || (node() && node()->isContentEditable()))) || (node() && node()->isDocumentNode());

}

void RenderBox::autoscroll()

{

    if (layer())

        layer()->autoscroll();

}

void RenderBox::panScroll(const IntPoint& source)

{

    if (layer())

        layer()->panScrollFromPoint(source);

}

int RenderBox::minPrefWidth() const

{

    if (prefWidthsDirty())

        const_cast<RenderBox*>(this)->calcPrefWidths();

    return m_minPrefWidth;

}

int RenderBox::maxPrefWidth() const

{

    if (prefWidthsDirty())

        const_cast<RenderBox*>(this)->calcPrefWidths();

    return m_maxPrefWidth;

}

int RenderBox::overrideSize() const

{

    if (!hasOverrideSize())

        return -1;

    return gOverrideSizeMap->get(this);

}

void RenderBox::setOverrideSize(int s)

{

    if (s == -1) {

        if (hasOverrideSize()) {

            setHasOverrideSize(false);

            gOverrideSizeMap->remove(this);

        }

    } else {

        if (!gOverrideSizeMap)

            gOverrideSizeMap = new OverrideSizeMap();

        setHasOverrideSize(true);

        gOverrideSizeMap->set(this, s);

    }

}

int RenderBox::overrideWidth() const

{

    return hasOverrideSize() ? overrideSize() : width();

}

int RenderBox::overrideHeight() const

{

    return hasOverrideSize() ? overrideSize() : height();

}

int RenderBox::calcBorderBoxWidth(int width) const

{

    int bordersPlusPadding = borderAndPaddingWidth();

    if (style()->boxSizing() == CONTENT_BOX)

        return width + bordersPlusPadding;

    return max(width, bordersPlusPadding);

}

int RenderBox::calcBorderBoxHeight(int height) const

{

    int bordersPlusPadding = borderAndPaddingHeight();

    if (style()->boxSizing() == CONTENT_BOX)

        return height + bordersPlusPadding;

    return max(height, bordersPlusPadding);

}

int RenderBox::calcContentBoxWidth(int width) const