/*

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

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

 *           (C) 2000 Dirk Mueller (mueller@kde.org)

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

 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

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

 *

 */

#ifndef RenderObject_h

#define RenderObject_h

#include "AffineTransform.h"

#include "CachedResourceClient.h"

#include "Document.h"

#include "Element.h"

#include "FloatQuad.h"

#include "PaintInfo.h"

#include "RenderObjectChildList.h"

#include "RenderStyle.h"

#include "TextAffinity.h"

#include "TransformationMatrix.h"

#include <wtf/UnusedParam.h>

#if PLATFORM(CG)

#define HAVE_PATH_BASED_BORDER_RADIUS_DRAWING 1

#endif

namespace WebCore {

class AnimationController;

class HitTestResult;

class InlineBox;

class InlineFlowBox;

class OverlapTestRequestClient;

class Path;

class Position;

class RenderBoxModelObject;

class RenderInline;

class RenderBlock;

class RenderFlow;

class RenderLayer;

class RenderTheme;

class TransformState;

class VisiblePosition;

#if ENABLE(SVG)

class RenderSVGResourceContainer;

#endif

enum HitTestFilter {

    HitTestAll,

    HitTestSelf,

    HitTestDescendants

};

enum HitTestAction {

    HitTestBlockBackground,

    HitTestChildBlockBackground,

    HitTestChildBlockBackgrounds,

    HitTestFloat,

    HitTestForeground

};

// Sides used when drawing borders and outlines.  This is in RenderObject rather than RenderBoxModelObject since outlines can

// be drawn by SVG around bounding boxes.

enum BoxSide {

    BSTop,

    BSBottom,

    BSLeft,

    BSRight

};

const int caretWidth = 1;

#if ENABLE(DASHBOARD_SUPPORT)

struct DashboardRegionValue {

    bool operator==(const DashboardRegionValue& o) const

    {

        return type == o.type && bounds == o.bounds && clip == o.clip && label == o.label;

    }

    bool operator!=(const DashboardRegionValue& o) const

    {

        return !(*this == o);

    }

    String label;

    IntRect bounds;

    IntRect clip;

    int type;

};

#endif

// Base class for all rendering tree objects.

class RenderObject : public CachedResourceClient {

    friend class RenderBlock;

    friend class RenderBox;

    friend class RenderLayer;

    friend class RenderObjectChildList;

    friend class RenderSVGContainer;

public:

    // Anonymous objects should pass the document as their node, and they will then automatically be

    // marked as anonymous in the constructor.

    RenderObject(Node*);

    virtual ~RenderObject();

    RenderTheme* theme() const;

    virtual const char* renderName() const = 0;

    RenderObject* parent() const { return m_parent; }

    bool isDescendantOf(const RenderObject*) const;

    RenderObject* previousSibling() const { return m_previous; }

    RenderObject* nextSibling() const { return m_next; }

    RenderObject* firstChild() const

    {

        if (const RenderObjectChildList* children = virtualChildren())

            return children->firstChild();

        return 0;

    }

    RenderObject* lastChild() const

    {

        if (const RenderObjectChildList* children = virtualChildren())

            return children->lastChild();

        return 0;

    }

    virtual RenderObjectChildList* virtualChildren() { return 0; }

    virtual const RenderObjectChildList* virtualChildren() const { return 0; }

    RenderObject* nextInPreOrder() const;

    RenderObject* nextInPreOrder(RenderObject* stayWithin) const;

    RenderObject* nextInPreOrderAfterChildren() const;

    RenderObject* nextInPreOrderAfterChildren(RenderObject* stayWithin) const;

    RenderObject* previousInPreOrder() const;

    RenderObject* childAt(unsigned) const;

    RenderObject* firstLeafChild() const;

    RenderObject* lastLeafChild() const;

    // The following six functions are used when the render tree hierarchy changes to make sure layers get

    // properly added and removed.  Since containership can be implemented by any subclass, and since a hierarchy

    // can contain a mixture of boxes and other object types, these functions need to be in the base class.

    RenderLayer* enclosingLayer() const;

    RenderLayer* enclosingSelfPaintingLayer() const;

    void addLayers(RenderLayer* parentLayer, RenderObject* newObject);

    void removeLayers(RenderLayer* parentLayer);

    void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);

    RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint, bool checkParent = true);

    // Convenience function for getting to the nearest enclosing box of a RenderObject.

    RenderBox* enclosingBox() const;

    RenderBoxModelObject* enclosingBoxModelObject() const;

    virtual bool isEmpty() const { return firstChild() == 0; }

#ifndef NDEBUG

    void setHasAXObject(bool flag) { m_hasAXObject = flag; }

    bool hasAXObject() const { return m_hasAXObject; }

    bool isSetNeedsLayoutForbidden() const { return m_setNeedsLayoutForbidden; }

    void setNeedsLayoutIsForbidden(bool flag) { m_setNeedsLayoutForbidden = flag; }

#endif

    // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline

    // children.

    virtual RenderBlock* firstLineBlock() const;

    // Called when an object that was floating or positioned becomes a normal flow object

    // again.  We have to make sure the render tree updates as needed to accommodate the new

    // normal flow object.

    void handleDynamicFloatPositionChange();

    // RenderObject tree manipulation

    //////////////////////////////////////////

    virtual bool canHaveChildren() const { return virtualChildren(); }

    virtual bool isChildAllowed(RenderObject*, RenderStyle*) const { return true; }

    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);

    virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0) { return addChild(newChild, beforeChild); }

    virtual void removeChild(RenderObject*);

    virtual bool createsAnonymousWrapper() const { return false; }

    //////////////////////////////////////////

protected:

    //////////////////////////////////////////

    // Helper functions. Dangerous to use!

    void setPreviousSibling(RenderObject* previous) { m_previous = previous; }

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

    void setParent(RenderObject* parent) { m_parent = parent; }

    //////////////////////////////////////////

private:

    void addAbsoluteRectForLayer(IntRect& result);

    void setLayerNeedsFullRepaint();

public:

#ifndef NDEBUG

    void showTreeForThis() const;

    void showRenderObject() const;

    // We don't make printedCharacters an optional parameter so that

    // showRenderObject can be called from gdb easily.

    void showRenderObject(int printedCharacters) const;

    void showRenderTreeAndMark(const RenderObject* markedObject1 = 0, const char* markedLabel1 = 0, const RenderObject* markedObject2 = 0, const char* markedLabel2 = 0, int depth = 0) const;

#endif

    static RenderObject* createObject(Node*, RenderStyle*);

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

private:

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

    void* operator new(size_t) throw();

public:

    RenderArena* renderArena() const { return document()->renderArena(); }

    virtual bool isApplet() const { return false; }

    virtual bool isBR() const { return false; }

    virtual bool isBlockFlow() const { return false; }

    virtual bool isBoxModelObject() const { return false; }

    virtual bool isCounter() const { return false; }

    virtual bool isEmbeddedObject() const { return false; }

    virtual bool isFieldset() const { return false; }

    virtual bool isFileUploadControl() const { return false; }

    virtual bool isFrame() const { return false; }

    virtual bool isFrameSet() const { return false; }

    virtual bool isImage() const { return false; }

    virtual bool isInlineBlockOrInlineTable() const { return false; }

    virtual bool isListBox() const { return false; }

    virtual bool isListItem() const { return false; }

    virtual bool isListMarker() const { return false; }

    virtual bool isMedia() const { return false; }

    virtual bool isMenuList() const { return false; }

#if ENABLE(METER_TAG)

    virtual bool isMeter() const { return false; }

#endif

#if ENABLE(PROGRESS_TAG)

    virtual bool isProgress() const { return false; }

#endif

    virtual bool isRenderBlock() const { return false; }

    virtual bool isRenderButton() const { return false; }

    virtual bool isRenderIFrame() const { return false; }

    virtual bool isRenderImage() const { return false; }

    virtual bool isRenderInline() const { return false; }

    virtual bool isRenderPart() const { return false; }

    virtual bool isRenderView() const { return false; }

    virtual bool isReplica() const { return false; }

#if ENABLE(RUBY)

    virtual bool isRuby() const { return false; }

    virtual bool isRubyBase() const { return false; }

    virtual bool isRubyRun() const { return false; }

    virtual bool isRubyText() const { return false; }

#endif

    virtual bool isSlider() const { return false; }

    virtual bool isTable() const { return false; }

    virtual bool isTableCell() const { return false; }

    virtual bool isTableCol() const { return false; }

    virtual bool isTableRow() const { return false; }

    virtual bool isTableSection() const { return false; }

    virtual bool isTextControl() const { return false; }

    virtual bool isTextArea() const { return false; }

    virtual bool isTextField() const { return false; }

    virtual bool isVideo() const { return false; }

    virtual bool isWidget() const { return false; }

    virtual bool isCanvas() const { return false; }

    bool isRoot() const { return document()->documentElement() == m_node; }

    bool isBody() const;

    bool isHR() const;

    bool isHTMLMarquee() const;

    inline bool isAfterContent() const;

    static inline bool isAfterContent(const RenderObject* obj) { return obj && obj->isAfterContent(); }

    bool childrenInline() const { return m_childrenInline; }

    void setChildrenInline(bool b = true) { m_childrenInline = b; }

    bool hasColumns() const { return m_hasColumns; }

    void setHasColumns(bool b = true) { m_hasColumns = b; }

    bool cellWidthChanged() const { return m_cellWidthChanged; }

    void setCellWidthChanged(bool b = true) { m_cellWidthChanged = b; }

    virtual bool requiresForcedStyleRecalcPropagation() const { return false; }

#if ENABLE(MATHML)

    virtual bool isRenderMathMLBlock() const { return false; }

#endif // ENABLE(MATHML)

#if ENABLE(SVG)

    // FIXME: Until all SVG renders can be subclasses of RenderSVGModelObject we have

    // to add SVG renderer methods to RenderObject with an ASSERT_NOT_REACHED() default implementation.

    virtual bool isSVGRoot() const { return false; }

    virtual bool isSVGContainer() const { return false; }

    virtual bool isSVGGradientStop() const { return false; }

    virtual bool isSVGHiddenContainer() const { return false; }

    virtual bool isRenderPath() const { return false; }

    virtual bool isSVGText() const { return false; }

    virtual bool isSVGInlineText() const { return false; }

    virtual bool isSVGImage() const { return false; }

    virtual bool isSVGForeignObject() const { return false; }

    virtual bool isSVGResourceContainer() const { return false; }

    virtual bool isSVGShadowTreeRootContainer() const { return false; }

    virtual RenderSVGResourceContainer* toRenderSVGResourceContainer();

    // FIXME: Those belong into a SVG specific base-class for all renderers (see above)

    // Unfortunately we don't have such a class yet, because it's not possible for all renderers

    // to inherit from RenderSVGObject -> RenderObject (some need RenderBlock inheritance for instance)

    virtual void setNeedsTransformUpdate() { }

    virtual void setNeedsBoundariesUpdate() { }

    // Per SVG 1.1 objectBoundingBox ignores clipping, masking, filter effects, opacity and stroke-width.

    // This is used for all computation of objectBoundingBox relative units and by SVGLocateable::getBBox().

    // NOTE: Markers are not specifically ignored here by SVG 1.1 spec, but we ignore them

    // since stroke-width is ignored (and marker size can depend on stroke-width).

    // objectBoundingBox is returned local coordinates.

    // The name objectBoundingBox is taken from the SVG 1.1 spec.

    virtual FloatRect objectBoundingBox() const;

    virtual FloatRect strokeBoundingBox() const;

    // Returns the smallest rectangle enclosing all of the painted content

    // respecting clipping, masking, filters, opacity, stroke-width and markers

    virtual FloatRect repaintRectInLocalCoordinates() const;

    // This only returns the transform="" value from the element

    // most callsites want localToParentTransform() instead.

    virtual AffineTransform localTransform() const;

    // Returns the full transform mapping from local coordinates to local coords for the parent SVG renderer

    // This includes any viewport transforms and x/y offsets as well as the transform="" value off the element.

    virtual const AffineTransform& localToParentTransform() const;

    // SVG uses FloatPoint precise hit testing, and passes the point in parent

    // coordinates instead of in repaint container coordinates.  Eventually the

    // rest of the rendering tree will move to a similar model.

    virtual bool nodeAtFloatPoint(const HitTestRequest&, HitTestResult&, const FloatPoint& pointInParent, HitTestAction);

#endif

    bool isAnonymous() const { return m_isAnonymous; }

    void setIsAnonymous(bool b) { m_isAnonymous = b; }

    bool isAnonymousBlock() const

    {

        return m_isAnonymous && style()->display() == BLOCK && style()->styleType() == NOPSEUDO && !isListMarker();

    }

    bool isAnonymousColumnsBlock() const { return style()->specifiesColumns() && isAnonymousBlock(); }

    bool isAnonymousColumnSpanBlock() const { return style()->columnSpan() && isAnonymousBlock(); }

    bool isElementContinuation() const { return node() && node()->renderer() != this; }

    bool isInlineElementContinuation() const { return isElementContinuation() && isInline(); }

    bool isBlockElementContinuation() const { return isElementContinuation() && !isInline(); }

    virtual RenderBoxModelObject* virtualContinuation() const { return 0; }

    bool isFloating() const { return m_floating; }

    bool isPositioned() const { return m_positioned; } // absolute or fixed positioning

    bool isRelPositioned() const { return m_relPositioned; } // relative positioning

    bool isText() const  { return m_isText; }

    bool isBox() const { return m_isBox; }

    bool isInline() const { return m_inline; }  // inline object

    bool isRunIn() const { return style()->display() == RUN_IN; } // run-in object

    bool isDragging() const { return m_isDragging; }

    bool isReplaced() const { return m_replaced; } // a "replaced" element (see CSS)

    bool hasLayer() const { return m_hasLayer; }

    bool hasBoxDecorations() const { return m_paintBackground; }

    bool mustRepaintBackgroundOrBorder() const;

    bool hasBackground() const

    {

        Color color = style()->visitedDependentColor(CSSPropertyBackgroundColor);

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

            return true;

        return style()->hasBackgroundImage();

    }

    bool needsLayout() const { return m_needsLayout || m_normalChildNeedsLayout || m_posChildNeedsLayout || m_needsPositionedMovementLayout; }

    bool selfNeedsLayout() const { return m_needsLayout; }

    bool needsPositionedMovementLayout() const { return m_needsPositionedMovementLayout; }

    bool needsPositionedMovementLayoutOnly() const { return m_needsPositionedMovementLayout && !m_needsLayout && !m_normalChildNeedsLayout && !m_posChildNeedsLayout; }

    bool posChildNeedsLayout() const { return m_posChildNeedsLayout; }

    bool normalChildNeedsLayout() const { return m_normalChildNeedsLayout; }

    bool prefWidthsDirty() const { return m_prefWidthsDirty; }

    bool isSelectionBorder() const;

    bool hasClip() const { return isPositioned() && style()->hasClip(); }

    bool hasOverflowClip() const { return m_hasOverflowClip; }

    bool hasTransform() const { return m_hasTransform; }

    bool hasMask() const { return style() && style()->hasMask(); }

    void drawLineForBoxSide(GraphicsContext*, int x1, int y1, int x2, int y2, BoxSide,

                            Color, EBorderStyle, int adjbw1, int adjbw2);

#if HAVE(PATH_BASED_BORDER_RADIUS_DRAWING)

    void drawBoxSideFromPath(GraphicsContext*, IntRect, Path, 

                            float thickness, float drawThickness, BoxSide, const RenderStyle*, 

                            Color, EBorderStyle);

#else

    // FIXME: This function should be removed when all ports implement GraphicsContext::clipConvexPolygon()!!

    // At that time, everyone can use RenderObject::drawBoxSideFromPath() instead. This should happen soon.

    void drawArcForBoxSide(GraphicsContext*, int x, int y, float thickness, IntSize radius, int angleStart,

                           int angleSpan, BoxSide, Color, EBorderStyle, bool firstCorner);

#endif

    IntRect borderInnerRect(const IntRect&, unsigned short topWidth, unsigned short bottomWidth,

                            unsigned short leftWidth, unsigned short rightWidth) const;

    // The pseudo element style can be cached or uncached.  Use the cached method if the pseudo element doesn't respect

    // any pseudo classes (and therefore has no concept of changing state).

    RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = 0) const;

    PassRefPtr<RenderStyle> getUncachedPseudoStyle(PseudoId, RenderStyle* parentStyle = 0, RenderStyle* ownStyle = 0) const;

    virtual void updateDragState(bool dragOn);

    RenderView* view() const;

    // Returns true if this renderer is rooted, and optionally returns the hosting view (the root of the hierarchy).

    bool isRooted(RenderView** = 0);

    Node* node() const { return m_isAnonymous ? 0 : m_node; }

    void setNode(Node* node) { m_node = node; }

    Document* document() const { return m_node->document(); }

    Frame* frame() const { return document()->frame(); }

    bool hasOutlineAnnotation() const;

    bool hasOutline() const { return style()->hasOutline() || hasOutlineAnnotation(); }

    // Returns the object containing this one. Can be different from parent for positioned elements.

    // If repaintContainer and repaintContainerSkipped are not null, on return *repaintContainerSkipped

    // is true if the renderer returned is an ancestor of repaintContainer.

    RenderObject* container(RenderBoxModelObject* repaintContainer = 0, bool* repaintContainerSkipped = 0) const;

    virtual RenderObject* hoverAncestor() const { return parent(); }

    // IE Extension that can be called on any RenderObject.  See the implementation for the details.

    RenderBoxModelObject* offsetParent() const;

    void markContainingBlocksForLayout(bool scheduleRelayout = true, RenderObject* newRoot = 0);

    void setNeedsLayout(bool b, bool markParents = true);

    void setChildNeedsLayout(bool b, bool markParents = true);

    void setNeedsPositionedMovementLayout();

    void setPrefWidthsDirty(bool, bool markParents = true);

    void invalidateContainerPrefWidths();

    void setNeedsLayoutAndPrefWidthsRecalc()

    {

        setNeedsLayout(true);

        setPrefWidthsDirty(true);

    }

    void setPositioned(bool b = true)  { m_positioned = b;  }

    void setRelPositioned(bool b = true) { m_relPositioned = b; }

    void setFloating(bool b = true) { m_floating = b; }

    void setInline(bool b = true) { m_inline = b; }

    void setHasBoxDecorations(bool b = true) { m_paintBackground = b; }

    void setIsText() { m_isText = true; }

    void setIsBox() { m_isBox = true; }

    void setReplaced(bool b = true) { m_replaced = b; }

    void setHasOverflowClip(bool b = true) { m_hasOverflowClip = b; }

    void setHasLayer(bool b = true) { m_hasLayer = b; }

    void setHasTransform(bool b = true) { m_hasTransform = b; }

    void setHasReflection(bool b = true) { m_hasReflection = b; }

    void scheduleRelayout();

    void updateFillImages(const FillLayer*, const FillLayer*);

    void updateImage(StyleImage*, StyleImage*);

    // for discussion of lineHeight see CSS2 spec

    virtual int lineHeight(bool firstLine, bool isRootLineBox = false) const;

    // for the vertical-align property of inline elements

    // the offset of baseline from the top of the object.

    virtual int baselinePosition(bool firstLine, bool isRootLineBox = false) const;

    virtual void paint(PaintInfo&, int tx, int ty);

    // Recursive function that computes the size and position of this object and all its descendants.

    virtual void layout();

    /* This function performs a layout only if one is needed. */

    void layoutIfNeeded() { if (needsLayout()) layout(); }

    // used for element state updates that cannot be fixed with a

    // repaint and do not need a relayout

    virtual void updateFromElement() { }

#if ENABLE(DASHBOARD_SUPPORT)

    virtual void addDashboardRegions(Vector<DashboardRegionValue>&);

    void collectDashboardRegions(Vector<DashboardRegionValue>&);

#endif

    bool hitTest(const HitTestRequest&, HitTestResult&, const IntPoint&, int tx, int ty, HitTestFilter = HitTestAll);

    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);

    virtual void updateHitTestResult(HitTestResult&, const IntPoint&);

    VisiblePosition positionForCoordinates(int x, int y);

    virtual VisiblePosition positionForPoint(const IntPoint&);

    VisiblePosition createVisiblePosition(int offset, EAffinity);

    VisiblePosition createVisiblePosition(const Position&);

    virtual void dirtyLinesFromChangedChild(RenderObject*);

    // Called to update a style that is allowed to trigger animations.

    // FIXME: Right now this will typically be called only when updating happens from the DOM on explicit elements.

    // We don't yet handle generated content animation such as first-letter or before/after (we'll worry about this later).

    void setAnimatableStyle(PassRefPtr<RenderStyle>);

    // Set the style of the object and update the state of the object accordingly.

    virtual void setStyle(PassRefPtr<RenderStyle>);