/*

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

#include "GraphicsContext.h"

#include "HTMLElement.h"

#include "HTMLNames.h"

#include "ImageBuffer.h"

#include "RenderBlock.h"

#include "RenderInline.h"

#include "RenderLayer.h"

#include "RenderView.h"

using namespace std;

namespace WebCore {

using namespace HTMLNames;

bool RenderBoxModelObject::s_wasFloating = false;

bool RenderBoxModelObject::s_hadLayer = false;

bool RenderBoxModelObject::s_layerWasSelfPainting = false;

RenderBoxModelObject::RenderBoxModelObject(Node* node)

    : RenderObject(node)

    , m_layer(0)

{

}

RenderBoxModelObject::~RenderBoxModelObject()

{

    // Our layer should have been destroyed and cleared by now

    ASSERT(!hasLayer());

    ASSERT(!m_layer);

}

void RenderBoxModelObject::destroyLayer()

{

    ASSERT(!hasLayer()); // Callers should have already called setHasLayer(false)

    ASSERT(m_layer);

    m_layer->destroy(renderArena());

    m_layer = 0;

}

void RenderBoxModelObject::destroy()

{

    // This must be done before we destroy the RenderObject.

    if (m_layer)

        m_layer->clearClipRects();

    // RenderObject::destroy calls back to destroyLayer() for layer destruction

    RenderObject::destroy();

}

bool RenderBoxModelObject::hasSelfPaintingLayer() const

{

    return m_layer && m_layer->isSelfPaintingLayer();

}

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

{

    s_wasFloating = isFloating();

    s_hadLayer = hasLayer();

    if (s_hadLayer)

        s_layerWasSelfPainting = layer()->isSelfPaintingLayer();

    // If our z-index changes value or our visibility changes,

    // we need to dirty our stacking context's z-order list.

    if (style() && newStyle) {

        if (parent()) {

            // Do a repaint with the old style first, e.g., for example if we go from

            // having an outline to not having an outline.

            if (diff == StyleDifferenceRepaintLayer) {

                layer()->repaintIncludingDescendants();

                if (!(style()->clip() == newStyle->clip()))

                    layer()->clearClipRectsIncludingDescendants();

            } else if (diff == StyleDifferenceRepaint || newStyle->outlineSize() < style()->outlineSize())

                repaint();

        }

        if (diff == StyleDifferenceLayout) {

            // When a layout hint happens, we go ahead and do a repaint of the layer, since the layer could

            // end up being destroyed.

            if (hasLayer()) {

                if (style()->position() != newStyle->position() ||

                    style()->zIndex() != newStyle->zIndex() ||

                    style()->hasAutoZIndex() != newStyle->hasAutoZIndex() ||

                    !(style()->clip() == newStyle->clip()) ||

                    style()->hasClip() != newStyle->hasClip() ||

                    style()->opacity() != newStyle->opacity() ||

                    style()->transform() != newStyle->transform())

                layer()->repaintIncludingDescendants();

            } else if (newStyle->hasTransform() || newStyle->opacity() < 1) {

                // If we don't have a layer yet, but we are going to get one because of transform or opacity,

                //  then we need to repaint the old position of the object.

                repaint();

            }

        }

        if (hasLayer() && (style()->hasAutoZIndex() != newStyle->hasAutoZIndex() ||

                           style()->zIndex() != newStyle->zIndex() ||

                           style()->visibility() != newStyle->visibility())) {

            layer()->dirtyStackingContextZOrderLists();

            if (style()->hasAutoZIndex() != newStyle->hasAutoZIndex() || style()->visibility() != newStyle->visibility())

                layer()->dirtyZOrderLists();

        }

    }

    RenderObject::styleWillChange(diff, newStyle);

}

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

{

    RenderObject::styleDidChange(diff, oldStyle);

    updateBoxModelInfoFromStyle();

    if (requiresLayer()) {

        if (!layer()) {

            if (s_wasFloating && isFloating())

                setChildNeedsLayout(true);

            m_layer = new (renderArena()) RenderLayer(this);

            setHasLayer(true);

            m_layer->insertOnlyThisLayer();

            if (parent() && !needsLayout() && containingBlock())

                m_layer->updateLayerPositions();

        }

    } else if (layer() && layer()->parent()) {

        setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.

        setHasReflection(false);

        m_layer->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer

        if (s_wasFloating && isFloating())

            setChildNeedsLayout(true);

    }

    if (layer()) {

        layer()->styleChanged(diff, oldStyle);

        if (s_hadLayer && layer()->isSelfPaintingLayer() != s_layerWasSelfPainting)

            setChildNeedsLayout(true);

    }

}

void RenderBoxModelObject::updateBoxModelInfoFromStyle()

{

    // Set the appropriate bits for a box model object.  Since all bits are cleared in styleWillChange,

    // we only check for bits that could possibly be set to true.

    setHasBoxDecorations(style()->hasBorder() || style()->hasBackground() || style()->hasAppearance() || style()->boxShadow());

    setInline(style()->isDisplayInlineType());

    setRelPositioned(style()->position() == RelativePosition);

}

int RenderBoxModelObject::relativePositionOffsetX() const

{

    // Objects that shrink to avoid floats normally use available line width when computing containing block width.  However

    // in the case of relative positioning using percentages, we can't do this.  The offset should always be resolved using the

    // available width of the containing block.  Therefore we don't use containingBlockWidthForContent() here, but instead explicitly

    // call availableWidth on our containing block.

    if (!style()->left().isAuto()) {

        RenderBlock* cb = containingBlock();

        if (!style()->right().isAuto() && containingBlock()->style()->direction() == RTL)

            return -style()->right().calcValue(cb->availableWidth());

        return style()->left().calcValue(cb->availableWidth());

    }

    if (!style()->right().isAuto()) {

        RenderBlock* cb = containingBlock();

        return -style()->right().calcValue(cb->availableWidth());

    }

    return 0;

}

int RenderBoxModelObject::relativePositionOffsetY() const

{

    if (!style()->top().isAuto())

        return style()->top().calcValue(containingBlock()->availableHeight());

    else if (!style()->bottom().isAuto())

        return -style()->bottom().calcValue(containingBlock()->availableHeight());

    return 0;

}

int RenderBoxModelObject::offsetLeft() const

{

    // If the element is the HTML body element or does not have an associated box

    // return 0 and stop this algorithm.

    if (isBody())

        return 0;

    RenderBoxModelObject* offsetPar = offsetParent();

    int xPos = (isBox() ? toRenderBox(this)->x() : 0);

    // If the offsetParent of the element is null, or is the HTML body element,

    // return the distance between the canvas origin and the left border edge 

    // of the element and stop this algorithm.

    if (offsetPar) {

        if (offsetPar->isBox() && !offsetPar->isBody())

            xPos -= toRenderBox(offsetPar)->borderLeft();

        if (!isPositioned()) {

            if (isRelPositioned())

                xPos += relativePositionOffsetX();

            RenderObject* curr = parent();

            while (curr && curr != offsetPar) {

                // FIXME: What are we supposed to do inside SVG content?

                if (curr->isBox() && !curr->isTableRow())

                    xPos += toRenderBox(curr)->x();

                curr = curr->parent();

            }

            if (offsetPar->isBox() && offsetPar->isBody() && !offsetPar->isRelPositioned() && !offsetPar->isPositioned())

                xPos += toRenderBox(offsetPar)->x();

        }

    }

    return xPos;

}

int RenderBoxModelObject::offsetTop() const

{

    // If the element is the HTML body element or does not have an associated box

    // return 0 and stop this algorithm.

    if (isBody())

        return 0;

    RenderBoxModelObject* offsetPar = offsetParent();

    int yPos = (isBox() ? toRenderBox(this)->y() : 0);

    // If the offsetParent of the element is null, or is the HTML body element,

    // return the distance between the canvas origin and the top border edge 

    // of the element and stop this algorithm.

    if (offsetPar) {

        if (offsetPar->isBox() && !offsetPar->isBody())

            yPos -= toRenderBox(offsetPar)->borderTop();

        if (!isPositioned()) {

            if (isRelPositioned())

                yPos += relativePositionOffsetY();

            RenderObject* curr = parent();

            while (curr && curr != offsetPar) {

                // FIXME: What are we supposed to do inside SVG content?

                if (curr->isBox() && !curr->isTableRow())

                    yPos += toRenderBox(curr)->y();

                curr = curr->parent();

            }

            if (offsetPar->isBox() && offsetPar->isBody() && !offsetPar->isRelPositioned() && !offsetPar->isPositioned())

                yPos += toRenderBox(offsetPar)->y();

        }

    }

    return yPos;

}

int RenderBoxModelObject::paddingTop(bool) const

{

    int w = 0;

    Length padding = style()->paddingTop();

    if (padding.isPercent())

        w = containingBlock()->availableWidth();

    return padding.calcMinValue(w);

}

int RenderBoxModelObject::paddingBottom(bool) const

{

    int w = 0;

    Length padding = style()->paddingBottom();

    if (padding.isPercent())

        w = containingBlock()->availableWidth();

    return padding.calcMinValue(w);

}

int RenderBoxModelObject::paddingLeft(bool) const

{

    int w = 0;

    Length padding = style()->paddingLeft();

    if (padding.isPercent())

        w = containingBlock()->availableWidth();

    return padding.calcMinValue(w);

}

int RenderBoxModelObject::paddingRight(bool) const

{

    int w = 0;

    Length padding = style()->paddingRight();

    if (padding.isPercent())

        w = containingBlock()->availableWidth();

    return padding.calcMinValue(w);

}

void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, const Color& c, const FillLayer* bgLayer, int tx, int ty, int w, int h, InlineFlowBox* box, CompositeOperator op)

{

    GraphicsContext* context = paintInfo.context;

    bool includeLeftEdge = box ? box->includeLeftEdge() : true;

    bool includeRightEdge = box ? box->includeRightEdge() : true;

    int bLeft = includeLeftEdge ? borderLeft() : 0;

    int bRight = includeRightEdge ? borderRight() : 0;

    int pLeft = includeLeftEdge ? paddingLeft() : 0;

    int pRight = includeRightEdge ? paddingRight() : 0;

    bool clippedToBorderRadius = false;

    if (style()->hasBorderRadius() && (includeLeftEdge || includeRightEdge)) {

        IntRect borderRect(tx, ty, w, h);

        if (borderRect.isEmpty())

            return;

        context->save();

        IntSize topLeft, topRight, bottomLeft, bottomRight;

        style()->getBorderRadiiForRect(borderRect, topLeft, topRight, bottomLeft, bottomRight);

        context->addRoundedRectClip(borderRect, includeLeftEdge ? topLeft : IntSize(),

                                                includeRightEdge ? topRight : IntSize(),

                                                includeLeftEdge ? bottomLeft : IntSize(),

                                                includeRightEdge ? bottomRight : IntSize());

        clippedToBorderRadius = true;

    }

    bool clippedWithLocalScrolling = hasOverflowClip() && bgLayer->attachment() == LocalBackgroundAttachment;

    if (clippedWithLocalScrolling) {

        // Clip to the overflow area.

        context->save();

        context->clip(toRenderBox(this)->overflowClipRect(tx, ty));

        // Now adjust our tx, ty, w, h to reflect a scrolled content box with borders at the ends.

        layer()->subtractScrolledContentOffset(tx, ty);

        w = bLeft + layer()->scrollWidth() + bRight;

        h = borderTop() + layer()->scrollHeight() + borderBottom();

    }

    if (bgLayer->clip() == PaddingFillBox || bgLayer->clip() == ContentFillBox) {

        // Clip to the padding or content boxes as necessary.

        bool includePadding = bgLayer->clip() == ContentFillBox;

        int x = tx + bLeft + (includePadding ? pLeft : 0);

        int y = ty + borderTop() + (includePadding ? paddingTop() : 0);

        int width = w - bLeft - bRight - (includePadding ? pLeft + pRight : 0);

        int height = h - borderTop() - borderBottom() - (includePadding ? paddingTop() + paddingBottom() : 0);

        context->save();

        context->clip(IntRect(x, y, width, height));

    } else if (bgLayer->clip() == TextFillBox) {

        // We have to draw our text into a mask that can then be used to clip background drawing.

        // First figure out how big the mask has to be.  It should be no bigger than what we need

        // to actually render, so we should intersect the dirty rect with the border box of the background.

        IntRect maskRect(tx, ty, w, h);

        maskRect.intersect(paintInfo.rect);

        // Now create the mask.

        OwnPtr<ImageBuffer> maskImage = ImageBuffer::create(maskRect.size());

        if (!maskImage)

            return;

        GraphicsContext* maskImageContext = maskImage->context();

        maskImageContext->translate(-maskRect.x(), -maskRect.y());

        // Now add the text to the clip.  We do this by painting using a special paint phase that signals to

        // InlineTextBoxes that they should just add their contents to the clip.

        PaintInfo info(maskImageContext, maskRect, PaintPhaseTextClip, true, 0, 0);

        if (box)

            box->paint(info, tx - box->x(), ty - box->y());

        else {

            int x = isBox() ? toRenderBox(this)->x() : 0;

            int y = isBox() ? toRenderBox(this)->y() : 0;

            paint(info, tx - x, ty - y);

        }

        // The mask has been created.  Now we just need to clip to it.

        context->save();

        context->clipToImageBuffer(maskRect, maskImage.get());

    }

    StyleImage* bg = bgLayer->image();

    bool shouldPaintBackgroundImage = bg && bg->canRender(style()->effectiveZoom());

    Color bgColor = c;

    // When this style flag is set, change existing background colors and images to a solid white background.

    // If there's no bg color or image, leave it untouched to avoid affecting transparency.

    // We don't try to avoid loading the background images, because this style flag is only set

    // when printing, and at that point we've already loaded the background images anyway. (To avoid

    // loading the background images we'd have to do this check when applying styles rather than

    // while rendering.)

    if (style()->forceBackgroundsToWhite()) {

        // Note that we can't reuse this variable below because the bgColor might be changed

        bool shouldPaintBackgroundColor = !bgLayer->next() && bgColor.isValid() && bgColor.alpha() > 0;

        if (shouldPaintBackgroundImage || shouldPaintBackgroundColor) {

            bgColor = Color::white;

            shouldPaintBackgroundImage = false;

        }

    }

    bool isRoot = this->isRoot();

    // Only fill with a base color (e.g., white) if we're the root document, since iframes/frames with

    // no background in the child document should show the parent's background.

    bool isOpaqueRoot = false;

    if (isRoot) {

        isOpaqueRoot = true;

        if (!bgLayer->next() && !(bgColor.isValid() && bgColor.alpha() == 255) && view()->frameView()) {

            Element* ownerElement = document()->ownerElement();

            if (ownerElement) {

                if (!ownerElement->hasTagName(frameTag)) {

                    // Locate the <body> element using the DOM.  This is easier than trying

                    // to crawl around a render tree with potential :before/:after content and

                    // anonymous blocks created by inline <body> tags etc.  We can locate the <body>

                    // render object very easily via the DOM.

                    HTMLElement* body = document()->body();

                    if (body) {

                        // Can't scroll a frameset document anyway.

                        isOpaqueRoot = body->hasLocalName(framesetTag);

                    }

                }

            } else

                isOpaqueRoot = !view()->frameView()->isTransparent();

        }

        view()->frameView()->setContentIsOpaque(isOpaqueRoot);

    }

    // Paint the color first underneath all images.

    if (!bgLayer->next()) {

        IntRect rect(tx, ty, w, h);

        rect.intersect(paintInfo.rect);

        // If we have an alpha and we are painting the root element, go ahead and blend with the base background color.

        if (isOpaqueRoot) {

            Color baseColor = view()->frameView()->baseBackgroundColor();

            if (baseColor.alpha() > 0) {

                context->save();

                context->setCompositeOperation(CompositeCopy);

                context->fillRect(rect, baseColor);

                context->restore();

            } else

                context->clearRect(rect);

        }

        if (bgColor.isValid() && bgColor.alpha() > 0)

            context->fillRect(rect, bgColor);

    }

    // no progressive loading of the background image

    if (shouldPaintBackgroundImage) {

        IntRect destRect;

        IntPoint phase;

        IntSize tileSize;

        calculateBackgroundImageGeometry(bgLayer, tx, ty, w, h, destRect, phase, tileSize);

        IntPoint destOrigin = destRect.location();

        destRect.intersect(paintInfo.rect);

        if (!destRect.isEmpty()) {

            phase += destRect.location() - destOrigin;

            CompositeOperator compositeOp = op == CompositeSourceOver ? bgLayer->composite() : op;

            RenderObject* clientForBackgroundImage = this;

            // Check if this is the root element painting a background layer propagated from <body>,

            // and pass the body's renderer as the client in that case.

            if (isRoot && !style()->hasBackground()) {

                ASSERT(node()->hasTagName(htmlTag));

                HTMLElement* body = document()->body();

                ASSERT(body);

                ASSERT(body->hasLocalName(bodyTag));

                ASSERT(body->renderer());

                if (body) {

                    if (RenderObject* bodyRenderer = body->renderer())

                        clientForBackgroundImage = bodyRenderer;

                }

            }

            context->drawTiledImage(bg->image(clientForBackgroundImage, tileSize), destRect, phase, tileSize, compositeOp);

        }

    }

    if (bgLayer->clip() != BorderFillBox)

        // Undo the background clip

        context->restore();

    if (clippedToBorderRadius)

        // Undo the border radius clip

        context->restore();

    if (clippedWithLocalScrolling) // Undo the clip for local background attachments.

        context->restore();

}

IntSize RenderBoxModelObject::calculateFillTileSize(const FillLayer* fillLayer, IntSize positioningAreaSize) const

{

    StyleImage* image = fillLayer->image();

    image->setImageContainerSize(positioningAreaSize); // Use the box established by background-origin.

    EFillSizeType type = fillLayer->size().type;

    switch (type) {

        case SizeLength: {

            int w = positioningAreaSize.width();

            int h = positioningAreaSize.height();

            Length layerWidth = fillLayer->size().size.width();

            Length layerHeight = fillLayer->size().size.height();

            if (layerWidth.isFixed())

                w = layerWidth.value();

            else if (layerWidth.isPercent())

                w = layerWidth.calcValue(positioningAreaSize.width());

            if (layerHeight.isFixed())

                h = layerHeight.value();

            else if (layerHeight.isPercent())

                h = layerHeight.calcValue(positioningAreaSize.height());

            // If one of the values is auto we have to use the appropriate

            // scale to maintain our aspect ratio.

            if (layerWidth.isAuto() && !layerHeight.isAuto())

                w = image->imageSize(this, style()->effectiveZoom()).width() * h / image->imageSize(this, style()->effectiveZoom()).height();        

            else if (!layerWidth.isAuto() && layerHeight.isAuto())

                h = image->imageSize(this, style()->effectiveZoom()).height() * w / image->imageSize(this, style()->effectiveZoom()).width();

            else if (layerWidth.isAuto() && layerHeight.isAuto()) {

                // If both width and height are auto, we just want to use the image's

                // intrinsic size.