/*

 * Copyright (C) 2003, 2009 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.

 */

#ifndef RenderLayer_h

#define RenderLayer_h

#include "RenderBox.h"

#include "ScrollBehavior.h"

#include "ScrollbarClient.h"

#include "Timer.h"

#include <wtf/OwnPtr.h>

namespace WebCore {

class CachedResource;

class HitTestRequest;

class HitTestResult;

class HitTestingTransformState;

class RenderFrameSet;

class RenderMarquee;

class RenderReplica;

class RenderScrollbarPart;

class RenderStyle;

class RenderTable;

class RenderText;

class RenderView;

class Scrollbar;

class TransformationMatrix;

#if USE(ACCELERATED_COMPOSITING)

class RenderLayerBacking;

class RenderLayerCompositor;

#endif

class ClipRects {

public:

    ClipRects()

        : m_refCnt(0)

        , m_fixed(false)

    {

    }

    ClipRects(const IntRect& r)

        : m_overflowClipRect(r)

        , m_fixedClipRect(r)

        , m_posClipRect(r)

        , m_refCnt(0)

        , m_fixed(false)

    {

    }

    ClipRects(const ClipRects& other)

        : m_overflowClipRect(other.overflowClipRect())

        , m_fixedClipRect(other.fixedClipRect())

        , m_posClipRect(other.posClipRect())

        , m_refCnt(0)

        , m_fixed(other.fixed())

    {

    }

    void reset(const IntRect& r)

    {

        m_overflowClipRect = r;

        m_fixedClipRect = r;

        m_posClipRect = r;

        m_fixed = false;

    }

    const IntRect& overflowClipRect() const { return m_overflowClipRect; }

    void setOverflowClipRect(const IntRect& r) { m_overflowClipRect = r; }

    const IntRect& fixedClipRect() const { return m_fixedClipRect; }

    void setFixedClipRect(const IntRect&r) { m_fixedClipRect = r; }

    const IntRect& posClipRect() const { return m_posClipRect; }

    void setPosClipRect(const IntRect& r) { m_posClipRect = r; }

    bool fixed() const { return m_fixed; }

    void setFixed(bool fixed) { m_fixed = fixed; }

    void ref() { m_refCnt++; }

    void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }

    void destroy(RenderArena*);

    // Overloaded new operator.

    void* operator new(size_t, RenderArena*) throw();

    // Overridden to prevent the normal delete from being called.

    void operator delete(void*, size_t);

    bool operator==(const ClipRects& other) const

    {

        return m_overflowClipRect == other.overflowClipRect() &&

               m_fixedClipRect == other.fixedClipRect() &&

               m_posClipRect == other.posClipRect() &&

               m_fixed == other.fixed();

    }

    ClipRects& operator=(const ClipRects& other)

    {

        m_overflowClipRect = other.overflowClipRect();

        m_fixedClipRect = other.fixedClipRect();

        m_posClipRect = other.posClipRect();

        m_fixed = other.fixed();

        return *this;

    }

    static IntRect infiniteRect() { return IntRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX); }

private:

    // The normal operator new is disallowed on all render objects.

    void* operator new(size_t) throw();

private:

    IntRect m_overflowClipRect;

    IntRect m_fixedClipRect;

    IntRect m_posClipRect;

    unsigned m_refCnt : 31;

    bool m_fixed : 1;

};

class RenderLayer : public ScrollbarClient {

public:

    friend class RenderReplica;

    RenderLayer(RenderBoxModelObject*);

    ~RenderLayer();

    RenderBoxModelObject* renderer() const { return m_renderer; }

    RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }

    RenderLayer* parent() const { return m_parent; }

    RenderLayer* previousSibling() const { return m_previous; }

    RenderLayer* nextSibling() const { return m_next; }

    RenderLayer* firstChild() const { return m_first; }

    RenderLayer* lastChild() const { return m_last; }

    void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);

    RenderLayer* removeChild(RenderLayer*);

    void removeOnlyThisLayer();

    void insertOnlyThisLayer();

    void repaintIncludingDescendants();

#if USE(ACCELERATED_COMPOSITING)

    // Indicate that the layer contents need to be repainted. Only has an effect

    // if layer compositing is being used,

    void setBackingNeedsRepaint();

    void setBackingNeedsRepaintInRect(const IntRect& r); // r is in the coordinate space of the layer's render object

    void repaintIncludingNonCompositingDescendants(RenderBoxModelObject* repaintContainer);

#endif

    void styleChanged(StyleDifference, const RenderStyle*);

    RenderMarquee* marquee() const { return m_marquee; }

    bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }

    bool isSelfPaintingLayer() const;

    bool requiresSlowRepaints() const;

    bool isTransparent() const;

    RenderLayer* transparentPaintingAncestor();

    void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer, PaintBehavior);

    bool hasReflection() const { return renderer()->hasReflection(); }

    bool isReflection() const { return renderer()->isReplica(); }

    RenderReplica* reflection() const { return m_reflection; }

    RenderLayer* reflectionLayer() const;

    const RenderLayer* root() const

    {

        const RenderLayer* curr = this;

        while (curr->parent())

            curr = curr->parent();

        return curr;

    }

    int x() const { return m_x; }

    int y() const { return m_y; }

    void setLocation(int x, int y)

    {

        m_x = x;

        m_y = y;

    }

    int width() const { return m_width; }

    int height() const { return m_height; }

    IntSize size() const { return IntSize(m_width, m_height); }

    void setWidth(int w) { m_width = w; }

    void setHeight(int h) { m_height = h; }

    int scrollWidth();

    int scrollHeight();

    void panScrollFromPoint(const IntPoint&);

    // Scrolling methods for layers that can scroll their overflow.

    void scrollByRecursively(int xDelta, int yDelta);

    IntSize scrolledContentOffset() const { return IntSize(scrollXOffset() + m_scrollLeftOverflow, scrollYOffset()); }

    int scrollXOffset() const { return m_scrollX + m_scrollOriginX; }

    int scrollYOffset() const { return m_scrollY; }

    void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true);

    void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }

    void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOriginX, y); }

    void scrollRectToVisible(const IntRect&, bool scrollToAnchor = false, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded);

    IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);

    void setHasHorizontalScrollbar(bool);

    void setHasVerticalScrollbar(bool);

    PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);

    void destroyScrollbar(ScrollbarOrientation);

    Scrollbar* horizontalScrollbar() const { return m_hBar.get(); }

    Scrollbar* verticalScrollbar() const { return m_vBar.get(); }

    int verticalScrollbarWidth() const;

    int horizontalScrollbarHeight() const;

    bool hasOverflowControls() const;

    void positionOverflowControls(int tx, int ty);

    bool isPointInResizeControl(const IntPoint& absolutePoint) const;

    bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);

    IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;

    void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect);

    void paintScrollCorner(GraphicsContext*, int tx, int ty, const IntRect& damageRect);

    void paintResizer(GraphicsContext*, int tx, int ty, const IntRect& damageRect);

    void updateScrollInfoAfterLayout();

    bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1.0f);

    void autoscroll();

    void resize(const PlatformMouseEvent&, const IntSize&);

    bool inResizeMode() const { return m_inResizeMode; }

    void setInResizeMode(bool b) { m_inResizeMode = b; }

    bool isRootLayer() const { return renderer()->isRenderView(); }

#if USE(ACCELERATED_COMPOSITING)

    RenderLayerCompositor* compositor() const;

    // Notification from the renderer that its content changed (e.g. current frame of image changed).

    // Allows updates of layer content without repainting.

    void rendererContentChanged();

#endif

    // Returns true if the accelerated compositing is enabled

    bool hasAcceleratedCompositing() const;

    void updateLayerPosition();

    enum UpdateLayerPositionsFlag {

        DoFullRepaint = 1,

        CheckForRepaint = 1 << 1,

        IsCompositingUpdateRoot = 1 << 2,

        UpdateCompositingLayers = 1 << 3,

        UpdatePagination = 1 << 4

    };

    typedef unsigned UpdateLayerPositionsFlags;

    void updateLayerPositions(UpdateLayerPositionsFlags = DoFullRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers, IntPoint* cachedOffset = 0);

    void updateTransform();

    void relativePositionOffset(int& relX, int& relY) const { relX += m_relX; relY += m_relY; }

    IntSize relativePositionOffset() const { return IntSize(m_relX, m_relY); }

    void clearClipRectsIncludingDescendants();

    void clearClipRects();

    void addBlockSelectionGapsBounds(const IntRect&);

    void clearBlockSelectionGapsBounds();

    void repaintBlockSelectionGaps();

    // Get the enclosing stacking context for this layer.  A stacking context is a layer

    // that has a non-auto z-index.

    RenderLayer* stackingContext() const;

    bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }

    void dirtyZOrderLists();

    void dirtyStackingContextZOrderLists();

    void updateZOrderLists();

    Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; }

    Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; }

    void dirtyNormalFlowList();

    void updateNormalFlowList();

    Vector<RenderLayer*>* normalFlowList() const { return m_normalFlowList; }

    bool hasVisibleContent() const { return m_hasVisibleContent; }

    bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }

    void setHasVisibleContent(bool);

    void dirtyVisibleContentStatus();

    // Gets the nearest enclosing positioned ancestor layer (also includes

    // the <html> layer and the root layer).

    RenderLayer* enclosingPositionedAncestor() const;

    // The layer relative to which clipping rects for this layer are computed.

    RenderLayer* clippingRoot() const;

#if USE(ACCELERATED_COMPOSITING)

    // Enclosing compositing layer; if includeSelf is true, may return this.

    RenderLayer* enclosingCompositingLayer(bool includeSelf = true) const;

    // Ancestor compositing layer, excluding this.

    RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(false); }

#endif

    void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;

    bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }

    int zIndex() const { return renderer()->style()->zIndex(); }

    // The two main functions that use the layer system.  The paint method

    // paints the layers that intersect the damage rect from back to

    // front.  The hitTest method looks for mouse events by walking

    // layers that intersect the point from front to back.

    void paint(GraphicsContext*, const IntRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0);

    bool hitTest(const HitTestRequest&, HitTestResult&);

    // This method figures out our layerBounds in coordinates relative to

    // |rootLayer}.  It also computes our background and foreground clip rects

    // for painting/event handling.

    void calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,

                        IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect, bool temporaryClipRects = false) const;

    // Compute and cache clip rects computed with the given layer as the root

    void updateClipRects(const RenderLayer* rootLayer);

    // Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors

    // (rather than computing them all from scratch up the parent chain).

    void calculateClipRects(const RenderLayer* rootLayer, ClipRects&, bool useCached = false) const;

    ClipRects* clipRects() const { return m_clipRects; }

    IntRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.

    IntRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.

    bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const;

    // Bounding box relative to some ancestor layer.

    IntRect boundingBox(const RenderLayer* rootLayer) const;

    // Bounding box in the coordinates of this layer.

    IntRect localBoundingBox() const;

    // Bounding box relative to the root.

    IntRect absoluteBoundingBox() const;

    void updateHoverActiveState(const HitTestRequest&, HitTestResult&);

    // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.

    IntRect repaintRect() const { return m_repaintRect; }

    IntRect repaintRectIncludingDescendants() const;

    void computeRepaintRects();

    void updateRepaintRectsAfterScroll(bool fixed = false);

    void setNeedsFullRepaint(bool f = true) { m_needsFullRepaint = f; }

    int staticX() const { return m_staticX; }

    int staticY() const { return m_staticY; }

    void setStaticX(int staticX) { m_staticX = staticX; }

    void setStaticY(int staticY) { m_staticY = staticY; }

    bool hasTransform() const { return renderer()->hasTransform(); }

    // Note that this transform has the transform-origin baked in.

    TransformationMatrix* transform() const { return m_transform.get(); }

    // currentTransform computes a transform which takes accelerated animations into account. The

    // resulting transform has transform-origin baked in. If the layer does not have a transform,

    // returns the identity matrix.

    TransformationMatrix currentTransform() const;

    TransformationMatrix renderableTransform(PaintBehavior) const;

    // Get the perspective transform, which is applied to transformed sublayers.

    // Returns true if the layer has a -webkit-perspective.

    // Note that this transform has the perspective-origin baked in.

    TransformationMatrix perspectiveTransform() const;

    FloatPoint perspectiveOrigin() const;

    bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }

    bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }

     // Overloaded new operator.  Derived classes must override operator new

    // in order to allocate out of the RenderArena.

    void* operator new(size_t, RenderArena*) throw();

    // Overridden to prevent the normal delete from being called.

    void operator delete(void*, size_t);

#if USE(ACCELERATED_COMPOSITING)

    bool isComposited() const { return m_backing != 0; }

    bool hasCompositedMask() const;

    RenderLayerBacking* backing() const { return m_backing.get(); }

    RenderLayerBacking* ensureBacking();

    void clearBacking();

#else

    bool isComposited() const { return false; }

    bool hasCompositedMask() const { return false; }

#endif

    bool paintsWithTransparency(PaintBehavior paintBehavior) const

    {

        return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());

    }

    bool paintsWithTransform(PaintBehavior paintBehavior) const

    {

        return transform() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());

    }

private:

    // The normal operator new is disallowed on all render objects.

    void* operator new(size_t) throw();

private:

    void setNextSibling(RenderLayer* next) { m_next = next; }

    void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }

    void setParent(RenderLayer* parent);

    void setFirstChild(RenderLayer* first) { m_first = first; }

    void setLastChild(RenderLayer* last) { m_last = last; }

    int renderBoxX() const { return renderer()->isBox() ? toRenderBox(renderer())->x() : 0; }

    int renderBoxY() const { return renderer()->isBox() ? toRenderBox(renderer())->y() : 0; }

    void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);

    void updateLayerListsIfNeeded();

    void updateCompositingAndLayerListsIfNeeded();

    enum PaintLayerFlag {

        PaintLayerHaveTransparency = 1,

        PaintLayerAppliedTransform = 1 << 1,

        PaintLayerTemporaryClipRects = 1 << 2,

        PaintLayerPaintingReflection = 1 << 3

    };

    typedef unsigned PaintLayerFlags;

    void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,

                    PaintBehavior, RenderObject* paintingRoot, OverlapTestRequestMap* = 0,

                    PaintLayerFlags = 0);

    void paintList(Vector<RenderLayer*>*, RenderLayer* rootLayer, GraphicsContext* p,

                   const IntRect& paintDirtyRect, PaintBehavior,

                   RenderObject* paintingRoot, OverlapTestRequestMap*,

                   PaintLayerFlags);

    void paintPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*,

                                  const IntRect& paintDirtyRect, PaintBehavior,

                                  RenderObject* paintingRoot, OverlapTestRequestMap*,

                                  PaintLayerFlags);

    void paintChildLayerIntoColumns(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*,

                                    const IntRect& paintDirtyRect, PaintBehavior,

                                    RenderObject* paintingRoot, OverlapTestRequestMap*,

                                    PaintLayerFlags, const Vector<RenderLayer*>& columnLayers, size_t columnIndex);

    RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,

                              const IntRect& hitTestRect, const IntPoint& hitTestPoint, bool appliedTransform,

                              const HitTestingTransformState* transformState = 0, double* zOffset = 0);

    RenderLayer* hitTestList(Vector<RenderLayer*>*, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,

                             const IntRect& hitTestRect, const IntPoint& hitTestPoint,

                             const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset,

                             const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);

    RenderLayer* hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,

                                            const IntRect& hitTestRect, const IntPoint& hitTestPoint,

                                            const HitTestingTransformState* transformState, double* zOffset);

    RenderLayer* hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,

                                          const IntRect& hitTestRect, const IntPoint& hitTestPoint,

                                          const HitTestingTransformState* transformState, double* zOffset,

                                          const Vector<RenderLayer*>& columnLayers, size_t columnIndex);

    PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,

                            const IntRect& hitTestRect, const IntPoint& hitTestPoint,

                            const HitTestingTransformState* containerTransformState) const;

    bool hitTestContents(const HitTestRequest&, HitTestResult&, const IntRect& layerBounds, const IntPoint& hitTestPoint, HitTestFilter) const;

    void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);

    bool shouldBeNormalFlowOnly() const; 

    // ScrollBarClient interface

    virtual void valueChanged(Scrollbar*);

    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);

    virtual bool isActive() const;

    virtual bool scrollbarCornerPresent() const;

    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;

    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;

    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;