/*

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

 * Copyright (C) 2010 Google 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 "HTMLFrameOwnerElement.h"

#include "HTMLNames.h"

#include "ImageBuffer.h"

#include "Path.h"

#include "RenderBlock.h"

#include "RenderInline.h"

#include "RenderLayer.h"

#include "RenderView.h"

#include <wtf/CurrentTime.h>

using namespace std;

namespace WebCore {

using namespace HTMLNames;

bool RenderBoxModelObject::s_wasFloating = false;

bool RenderBoxModelObject::s_hadLayer = false;

bool RenderBoxModelObject::s_layerWasSelfPainting = false;

static const double cInterpolationCutoff = 800. * 800.;

static const double cLowQualityTimeThreshold = 0.500; // 500 ms

typedef HashMap<RenderBoxModelObject*, IntSize> LastPaintSizeMap;

class ImageQualityController : public Noncopyable {

public:

    ImageQualityController();

    bool shouldPaintAtLowQuality(GraphicsContext*, RenderBoxModelObject*, Image*, const IntSize&);

    void objectDestroyed(RenderBoxModelObject*);

private:

    void highQualityRepaintTimerFired(Timer<ImageQualityController>*);

    void restartTimer();

    LastPaintSizeMap m_lastPaintSizeMap;

    Timer<ImageQualityController> m_timer;

    bool m_animatedResizeIsActive;

};

ImageQualityController::ImageQualityController()

    : m_timer(this, &ImageQualityController::highQualityRepaintTimerFired)

    , m_animatedResizeIsActive(false)

{

}

void ImageQualityController::objectDestroyed(RenderBoxModelObject* object)

{

    m_lastPaintSizeMap.remove(object);

    if (m_lastPaintSizeMap.isEmpty()) {

        m_animatedResizeIsActive = false;

        m_timer.stop();

    }

}

void ImageQualityController::highQualityRepaintTimerFired(Timer<ImageQualityController>*)

{

    if (m_animatedResizeIsActive) {

        m_animatedResizeIsActive = false;

        for (LastPaintSizeMap::iterator it = m_lastPaintSizeMap.begin(); it != m_lastPaintSizeMap.end(); ++it)

            it->first->repaint();

    }

}

void ImageQualityController::restartTimer()

{

    m_timer.startOneShot(cLowQualityTimeThreshold);

}

bool ImageQualityController::shouldPaintAtLowQuality(GraphicsContext* context, RenderBoxModelObject* object, Image* image, const IntSize& size)

{

    // If the image is not a bitmap image, then none of this is relevant and we just paint at high

    // quality.

    if (!image || !image->isBitmapImage() || context->paintingDisabled())

        return false;

    // Make sure to use the unzoomed image size, since if a full page zoom is in effect, the image

    // is actually being scaled.

    IntSize imageSize(image->width(), image->height());

    // Look ourselves up in the hashtable.

    LastPaintSizeMap::iterator i = m_lastPaintSizeMap.find(object);

    const AffineTransform& currentTransform = context->getCTM();

    bool contextIsScaled = !currentTransform.isIdentityOrTranslationOrFlipped();

    if (!contextIsScaled && imageSize == size) {

        // There is no scale in effect. If we had a scale in effect before, we can just remove this object from the list.

        if (i != m_lastPaintSizeMap.end())

            m_lastPaintSizeMap.remove(object);

        return false;

    }

    // There is no need to hash scaled images that always use low quality mode when the page demands it. This is the iChat case.

    if (object->document()->page()->inLowQualityImageInterpolationMode()) {

        double totalPixels = static_cast<double>(image->width()) * static_cast<double>(image->height());

        if (totalPixels > cInterpolationCutoff)

            return true;

    }

    // If an animated resize is active, paint in low quality and kick the timer ahead.

    if (m_animatedResizeIsActive) {

        m_lastPaintSizeMap.set(object, size);

        restartTimer();

        return true;

    }

    // If this is the first time resizing this image, or its size is the

    // same as the last resize, draw at high res, but record the paint

    // size and set the timer.

    if (i == m_lastPaintSizeMap.end() || size == i->second) {

        restartTimer();

        m_lastPaintSizeMap.set(object, size);

        return false;

    }

    // If the timer is no longer active, draw at high quality and don't

    // set the timer.

    if (!m_timer.isActive()) {

        objectDestroyed(object);

        return false;

    }

    // This object has been resized to two different sizes while the timer

    // is active, so draw at low quality, set the flag for animated resizes and

    // the object to the list for high quality redraw.

    m_lastPaintSizeMap.set(object, size);

    m_animatedResizeIsActive = true;

    restartTimer();

    return true;

}

static ImageQualityController* imageQualityController()

{

    static ImageQualityController* controller = new ImageQualityController;

    return controller;

}

void RenderBoxModelObject::setSelectionState(SelectionState s)

{

    if (selectionState() == s)

        return;

    if (s == SelectionInside && selectionState() != SelectionNone)

        return;

    if ((s == SelectionStart && selectionState() == SelectionEnd)

        || (s == SelectionEnd && selectionState() == SelectionStart))

        RenderObject::setSelectionState(SelectionBoth);

    else

        RenderObject::setSelectionState(s);

    // FIXME:

    // We should consider whether it is OK propagating to ancestor RenderInlines.

    // This is a workaround for http://webkit.org/b/32123

    RenderBlock* cb = containingBlock();

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

        cb->setSelectionState(s);

}

bool RenderBoxModelObject::shouldPaintAtLowQuality(GraphicsContext* context, Image* image, const IntSize& size)

{

    return imageQualityController()->shouldPaintAtLowQuality(context, this, image, size);

}

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

    imageQualityController()->objectDestroyed(this);

}

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(hasBackground() || style()->hasBorder() || 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, RenderObject* backgroundObject)

{

    GraphicsContext* context = paintInfo.context;

    if (context->paintingDisabled())

        return;

    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.

        IntSize offset = layer()->scrolledContentOffset();

        tx -= offset.width();

        ty -= offset.height();

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