/*

 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

 *

 * Portions are Copyright (C) 1998 Netscape Communications Corporation.

 *

 * Other contributors:

 *   Robert O'Callahan <roc+@cs.cmu.edu>

 *   David Baron <dbaron@fas.harvard.edu>

 *   Christian Biesinger <cbiesinger@web.de>

 *   Randall Jesup <rjesup@wgate.com>

 *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>

 *   Josh Soref <timeless@mac.com>

 *   Boris Zbarsky <bzbarsky@mit.edu>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 * Alternatively, the contents of this file may be used under the terms

 * of either the Mozilla Public License Version 1.1, found at

 * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public

 * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html

 * (the "GPL"), in which case the provisions of the MPL or the GPL are

 * applicable instead of those above.  If you wish to allow use of your

 * version of this file only under the terms of one of those two

 * licenses (the MPL or the GPL) and not to allow others to use your

 * version of this file under the LGPL, indicate your decision by

 * deletingthe provisions above and replace them with the notice and

 * other provisions required by the MPL or the GPL, as the case may be.

 * If you do not delete the provisions above, a recipient may use your

 * version of this file under any of the LGPL, the MPL or the GPL.

 */

#include "config.h"

#include "RenderLayer.h"

#include "CSSPropertyNames.h"

#include "Document.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameView.h"

#include "FrameTree.h"

#include "GraphicsContext.h"

#include "HTMLMarqueeElement.h"

#include "HTMLNames.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "OverflowEvent.h"

#include "PlatformMouseEvent.h"

#include "PlatformScrollBar.h" 

#include "RenderArena.h"

#include "RenderInline.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "SelectionController.h"

#if ENABLE(SVG)

#include "SVGNames.h"

#endif

#define MIN_INTERSECT_FOR_REVEAL 32

using namespace std;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

#ifndef NDEBUG

static bool inRenderLayerDestroy;

#endif

const RenderLayer::ScrollAlignment RenderLayer::gAlignCenterIfNeeded = { RenderLayer::noScroll, RenderLayer::alignCenter, RenderLayer::alignToClosestEdge };

const RenderLayer::ScrollAlignment RenderLayer::gAlignToEdgeIfNeeded = { RenderLayer::noScroll, RenderLayer::alignToClosestEdge, RenderLayer::alignToClosestEdge };

const RenderLayer::ScrollAlignment RenderLayer::gAlignCenterAlways = { RenderLayer::alignCenter, RenderLayer::alignCenter, RenderLayer::alignCenter };

const RenderLayer::ScrollAlignment RenderLayer::gAlignTopAlways = { RenderLayer::alignTop, RenderLayer::alignTop, RenderLayer::alignTop };

const RenderLayer::ScrollAlignment RenderLayer::gAlignBottomAlways = { RenderLayer::alignBottom, RenderLayer::alignBottom, RenderLayer::alignBottom };

const int MinimumWidthWhileResizing = 100;

const int MinimumHeightWhileResizing = 40;

void* ClipRects::operator new(size_t sz, RenderArena* renderArena) throw()

{

    return renderArena->allocate(sz);

}

void ClipRects::operator delete(void* ptr, size_t sz)

{

    // Stash size where destroy can find it.

    *(size_t *)ptr = sz;

}

void ClipRects::destroy(RenderArena* renderArena)

{

    delete this;

    // Recover the size left there for us by operator delete and free the memory.

    renderArena->free(*(size_t *)this, this);

}

RenderLayer::RenderLayer(RenderObject* object)

    : m_object(object)

    , m_parent(0)

    , m_previous(0)

    , m_next(0)

    , m_first(0)

    , m_last(0)

    , m_relX(0)

    , m_relY(0)

    , m_x(0)

    , m_y(0)

    , m_width(0)

    , m_height(0)

    , m_scrollX(0)

    , m_scrollY(0)

    , m_scrollOriginX(0)

    , m_scrollLeftOverflow(0)

    , m_scrollWidth(0)

    , m_scrollHeight(0)

    , m_inResizeMode(false)

    , m_posZOrderList(0)

    , m_negZOrderList(0)

    , m_overflowList(0)

    , m_clipRects(0) 

    , m_scrollDimensionsDirty(true)

    , m_zOrderListsDirty(true)

    , m_overflowListDirty(true)

    , m_isOverflowOnly(shouldBeOverflowOnly())

    , m_usedTransparency(false)

    , m_inOverflowRelayout(false)

    , m_needsFullRepaint(false)

    , m_overflowStatusDirty(true)

    , m_visibleContentStatusDirty(true)

    , m_hasVisibleContent(false)

    , m_visibleDescendantStatusDirty(false)

    , m_hasVisibleDescendant(false)

    , m_marquee(0)

    , m_staticX(0)

    , m_staticY(0)

{

    if (!object->firstChild() && object->style()) {

        m_visibleContentStatusDirty = false;

        m_hasVisibleContent = object->style()->visibility() == VISIBLE;

    }

}

RenderLayer::~RenderLayer()

{

    destroyScrollbar(HorizontalScrollbar);

    destroyScrollbar(VerticalScrollbar);

    // Child layers will be deleted by their corresponding render objects, so

    // we don't need to delete them ourselves.

    delete m_posZOrderList;

    delete m_negZOrderList;

    delete m_overflowList;

    delete m_marquee;

    // Make sure we have no lingering clip rects.

    ASSERT(!m_clipRects);

}

void RenderLayer::updateLayerPositions(bool doFullRepaint, bool checkForRepaint)

{

    if (doFullRepaint) {

        m_object->repaint();

        checkForRepaint = doFullRepaint = false;

    }

    updateLayerPosition(); // For relpositioned layers or non-positioned layers,

                           // we need to keep in sync, since we may have shifted relative

                           // to our parent layer.

    positionOverflowControls();

    updateVisibilityStatus();

    if (m_hasVisibleContent) {

        RenderView* view = m_object->view();

        ASSERT(view);

        // FIXME: Optimize using LayoutState and remove the disableLayoutState() call

        // from updateScrollInfoAfterLayout().

        ASSERT(!view->layoutState());

        IntRect newRect = m_object->absoluteClippedOverflowRect();

        IntRect newOutlineBox = m_object->absoluteOutlineBox();

        if (checkForRepaint) {

            if (view && !view->printing()) {

                if (m_needsFullRepaint) {

                    view->repaintViewRectangle(m_repaintRect);

                    if (newRect != m_repaintRect)

                        view->repaintViewRectangle(newRect);

                } else

                    m_object->repaintAfterLayoutIfNeeded(m_repaintRect, m_outlineBox);

            }

        }

        m_repaintRect = newRect;

        m_outlineBox = newOutlineBox;

    } else {

        m_repaintRect = IntRect();

        m_outlineBox = IntRect();

    }

    m_needsFullRepaint = false;

    for (RenderLayer* child = firstChild(); child; child = child->nextSibling())

        child->updateLayerPositions(doFullRepaint, checkForRepaint);

    // With all our children positioned, now update our marquee if we need to.

    if (m_marquee)

        m_marquee->updateMarqueePosition();

}

void RenderLayer::setHasVisibleContent(bool b) 

{ 

    if (m_hasVisibleContent == b && !m_visibleContentStatusDirty)

        return;

    m_visibleContentStatusDirty = false; 

    m_hasVisibleContent = b;

    if (m_hasVisibleContent) {

        m_repaintRect = renderer()->absoluteClippedOverflowRect();

        m_outlineBox = renderer()->absoluteOutlineBox();

    }

    if (parent())

        parent()->childVisibilityChanged(m_hasVisibleContent);

}

void RenderLayer::dirtyVisibleContentStatus() 

{ 

    m_visibleContentStatusDirty = true; 

    if (parent())

        parent()->dirtyVisibleDescendantStatus();

}

void RenderLayer::childVisibilityChanged(bool newVisibility) 

{ 

    if (m_hasVisibleDescendant == newVisibility || m_visibleDescendantStatusDirty)

        return;

    if (newVisibility) {

        RenderLayer* l = this;

        while (l && !l->m_visibleDescendantStatusDirty && !l->m_hasVisibleDescendant) {

            l->m_hasVisibleDescendant = true;

            l = l->parent();

        }

    } else 

        dirtyVisibleDescendantStatus();

}

void RenderLayer::dirtyVisibleDescendantStatus()

{

    RenderLayer* l = this;

    while (l && !l->m_visibleDescendantStatusDirty) {

        l->m_visibleDescendantStatusDirty = true;

        l = l->parent();

    }

}

void RenderLayer::updateVisibilityStatus()

{

    if (m_visibleDescendantStatusDirty) {

        m_hasVisibleDescendant = false;

        for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {

            child->updateVisibilityStatus();        

            if (child->m_hasVisibleContent || child->m_hasVisibleDescendant) {

                m_hasVisibleDescendant = true;

                break;

            }

        }

        m_visibleDescendantStatusDirty = false;

    }

    if (m_visibleContentStatusDirty) {

        if (m_object->style()->visibility() == VISIBLE)

            m_hasVisibleContent = true;

        else {

            // layer may be hidden but still have some visible content, check for this

            m_hasVisibleContent = false;

            RenderObject* r = m_object->firstChild();

            while (r) {

                if (r->style()->visibility() == VISIBLE && !r->hasLayer()) {

                    m_hasVisibleContent = true;

                    break;

                }

                if (r->firstChild() && !r->hasLayer())

                    r = r->firstChild();

                else if (r->nextSibling())

                    r = r->nextSibling();

                else {

                    do {

                        r = r->parent();

                        if (r==m_object)

                            r = 0;

                    } while (r && !r->nextSibling());

                    if (r)

                        r = r->nextSibling();

                }

            }

        }    

        m_visibleContentStatusDirty = false; 

    }

}

void RenderLayer::updateLayerPosition()

{

    // Clear our cached clip rect information.

    clearClipRect();

    int x = m_object->xPos();

    int y = m_object->yPos() - m_object->borderTopExtra();

    if (!m_object->isPositioned() && m_object->parent()) {

        // We must adjust our position by walking up the render tree looking for the

        // nearest enclosing object with a layer.

        RenderObject* curr = m_object->parent();

        while (curr && !curr->hasLayer()) {

            if (!curr->isTableRow()) {

                // Rows and cells share the same coordinate space (that of the section).

                // Omit them when computing our xpos/ypos.

                x += curr->xPos();

                y += curr->yPos();

            }

            curr = curr->parent();

        }

        y += curr->borderTopExtra();

        if (curr->isTableRow()) {

            // Put ourselves into the row coordinate space.

            x -= curr->xPos();

            y -= curr->yPos();

        }

    }

    m_relX = m_relY = 0;

    if (m_object->isRelPositioned()) {

        m_relX = static_cast<RenderBox*>(m_object)->relativePositionOffsetX();

        m_relY = static_cast<RenderBox*>(m_object)->relativePositionOffsetY();

        x += m_relX; y += m_relY;

    }

    // Subtract our parent's scroll offset.

    if (m_object->isPositioned() && enclosingPositionedAncestor()) {

        RenderLayer* positionedParent = enclosingPositionedAncestor();

        // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.

        positionedParent->subtractScrollOffset(x, y);

        if (m_object->isPositioned()) {

            IntSize offset = static_cast<RenderBox*>(m_object)->offsetForPositionedInContainer(positionedParent->renderer());

            x += offset.width();

            y += offset.height();

        }

    } else if (parent())

        parent()->subtractScrollOffset(x, y);

    setPos(x,y);

    setWidth(m_object->width());

    setHeight(m_object->height() + m_object->borderTopExtra() + m_object->borderBottomExtra());

    if (!m_object->hasOverflowClip()) {

        if (m_object->overflowWidth() > m_object->width())

            setWidth(m_object->overflowWidth());

        if (m_object->overflowHeight() > m_object->height())

            setHeight(m_object->overflowHeight());

    }

}

RenderLayer *RenderLayer::stackingContext() const

{

    RenderLayer* curr = parent();

    for ( ; curr && !curr->m_object->isRenderView() && !curr->m_object->isRoot() &&

          curr->m_object->style()->hasAutoZIndex();

          curr = curr->parent());

    return curr;

}

RenderLayer*

RenderLayer::enclosingPositionedAncestor() const

{

    RenderLayer* curr = parent();

    for ( ; curr && !curr->m_object->isRenderView() && !curr->m_object->isRoot() &&

         !curr->m_object->isPositioned() && !curr->m_object->isRelPositioned();

         curr = curr->parent());

    return curr;

}

bool

RenderLayer::isTransparent() const

{

#if ENABLE(SVG)

    if (m_object->node()->namespaceURI() == SVGNames::svgNamespaceURI)

        return false;

#endif

    return m_object->isTransparent();

}

RenderLayer*

RenderLayer::transparentAncestor()

{

    RenderLayer* curr = parent();

    for ( ; curr && !curr->isTransparent(); curr = curr->parent());

    return curr;

}

static IntRect transparencyClipBox(RenderLayer* l)

{

    // FIXME: Although this completely ignores clipping, we ultimately intersect with the

    // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it

    // would be better to respect clips.

    IntRect clipRect = l->absoluteBoundingBox();

    // Note: we don't have to walk z-order lists since transparent elements always establish

    // a stacking context.  This means we can just walk the layer tree directly. 

    for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling())

        clipRect.unite(transparencyClipBox(curr));

    return clipRect;

}

void RenderLayer::beginTransparencyLayers(GraphicsContext* p, const IntRect& paintDirtyRect)

{

    if (p->paintingDisabled() || (isTransparent() && m_usedTransparency))

        return;

    RenderLayer* ancestor = transparentAncestor();

    if (ancestor)

        ancestor->beginTransparencyLayers(p, paintDirtyRect);

    if (isTransparent()) {

        m_usedTransparency = true;

        IntRect clipRect = transparencyClipBox(this);

        clipRect.intersect(paintDirtyRect);

        p->save();

        p->clip(clipRect);

        p->beginTransparencyLayer(renderer()->opacity());

    }

}

void* RenderLayer::operator new(size_t sz, RenderArena* renderArena) throw()

{

    return renderArena->allocate(sz);

}

void RenderLayer::operator delete(void* ptr, size_t sz)

{

    ASSERT(inRenderLayerDestroy);

    // Stash size where destroy can find it.

    *(size_t *)ptr = sz;

}

void RenderLayer::destroy(RenderArena* renderArena)

{

#ifndef NDEBUG

    inRenderLayerDestroy = true;

#endif

    delete this;

#ifndef NDEBUG

    inRenderLayerDestroy = false;

#endif

    // Recover the size left there for us by operator delete and free the memory.

    renderArena->free(*(size_t *)this, this);

}

void RenderLayer::addChild(RenderLayer *child, RenderLayer* beforeChild)

{

    RenderLayer* prevSibling = beforeChild ? beforeChild->previousSibling() : lastChild();

    if (prevSibling) {

        child->setPreviousSibling(prevSibling);

        prevSibling->setNextSibling(child);

    }

    else

        setFirstChild(child);

    if (beforeChild) {

        beforeChild->setPreviousSibling(child);

        child->setNextSibling(beforeChild);

    }

    else

        setLastChild(child);

    child->setParent(this);

    if (child->isOverflowOnly())

        dirtyOverflowList();

    else {

        // Dirty the z-order list in which we are contained.  The stackingContext() can be null in the

        // case where we're building up generated content layers.  This is ok, since the lists will start

        // off dirty in that case anyway.

        RenderLayer* stackingContext = child->stackingContext();

        if (stackingContext)

            stackingContext->dirtyZOrderLists();

    }

    child->updateVisibilityStatus();

    if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)

        childVisibilityChanged(true);

}

RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)

{

    // remove the child

    if (oldChild->previousSibling())

        oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());

    if (oldChild->nextSibling())

        oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());

    if (m_first == oldChild)

        m_first = oldChild->nextSibling();

    if (m_last == oldChild)

        m_last = oldChild->previousSibling();

    if (oldChild->isOverflowOnly())