auto import from //depot/cupcake/@135843

1 files changed, 256 insertions, 0 deletions

diff --git a/WebCore/rendering/RenderBox.h b/WebCore/rendering/RenderBox.h
new file mode 100644
index 0000000..133ae37
--- /dev/null
+++ b/WebCore/rendering/RenderBox.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ *           (C) 1999 Antti Koivisto (koivisto@kde.org)
+ * Copyright (C) 2003, 2006, 2007 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.
+ *
+ */
+
+#ifndef RenderBox_h
+#define RenderBox_h
+
+#include "RenderObject.h"
+
+namespace WebCore {
+
+    enum WidthType { Width, MinWidth, MaxWidth };
+
+class RenderBox : public RenderObject {
+public:
+    RenderBox(Node*);
+    virtual ~RenderBox();
+
+    virtual const char* renderName() const { return "RenderBox"; }
+
+    virtual void paint(PaintInfo&, int tx, int ty);
+    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
+
+    virtual void destroy();
+
+    virtual int minPrefWidth() const;
+    virtual int maxPrefWidth() const;
+
+    virtual int overrideSize() const;
+    virtual int overrideWidth() const;
+    virtual int overrideHeight() const;
+    virtual void setOverrideSize(int);
+
+    virtual bool absolutePosition(int& x, int& y, bool fixed = false) const;
+
+    virtual int xPos() const { return m_x; }
+    virtual int yPos() const { return m_y; }
+    virtual void setPos(int x, int y);
+
+    virtual int width() const { return m_width; }
+    virtual int height() const { return m_height; }
+    virtual void setWidth(int width) { m_width = width; }
+    virtual void setHeight(int height) { m_height = height; }
+
+    virtual int marginTop() const { return m_marginTop; }
+    virtual int marginBottom() const { return m_marginBottom; }
+    virtual int marginLeft() const { return m_marginLeft; }
+    virtual int marginRight() const { return m_marginRight; }
+
+    virtual IntRect borderBox() const { return IntRect(0, -borderTopExtra(), width(), height() + borderTopExtra() + borderBottomExtra()); }
+
+    int calcBorderBoxWidth(int width) const;
+    int calcBorderBoxHeight(int height) const;
+    int calcContentBoxWidth(int width) const;
+    int calcContentBoxHeight(int height) const;
+
+    virtual void borderFitAdjust(int& x, int& w) const {}; // Shrink the box in which the border paints if border-fit is set.
+
+    // This method is now public so that centered objects like tables that are
+    // shifted right by left-aligned floats can recompute their left and
+    // right margins (so that they can remain centered after being
+    // shifted. -dwh
+    void calcHorizontalMargins(const Length& marginLeft, const Length& marginRight, int containerWidth);
+
+    virtual void position(InlineBox*);
+
+    virtual void dirtyLineBoxes(bool fullLayout, bool isRootLineBox = false);
+
+    // For inline replaced elements, this function returns the inline box that owns us.  Enables
+    // the replaced RenderObject to quickly determine what line it is contained on and to easily
+    // iterate over structures on the line.
+    virtual InlineBox* inlineBoxWrapper() const { return m_inlineBoxWrapper; }
+    virtual void setInlineBoxWrapper(InlineBox* boxWrapper) { m_inlineBoxWrapper = boxWrapper; }
+    virtual void deleteLineBoxWrapper();
+
+    virtual int lowestPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+    virtual int rightmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+    virtual int leftmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+
+    virtual IntRect absoluteClippedOverflowRect();
+    virtual void computeAbsoluteRepaintRect(IntRect&, bool fixed = false);
+    IntSize offsetForPositionedInContainer(RenderObject*) const;
+
+    virtual void repaintDuringLayoutIfMoved(const IntRect&);
+
+    virtual int containingBlockWidth() const;
+
+    virtual void calcWidth();
+    virtual void calcHeight();
+
+    bool stretchesToViewHeight() const
+    {
+        return style()->htmlHacks() && style()->height().isAuto() && !isFloatingOrPositioned() && (isRoot() || isBody());
+    }
+
+    virtual IntSize intrinsicSize() const { return IntSize(); }
+
+    // Whether or not the element shrinks to its intrinsic width (rather than filling the width
+    // of a containing block).  HTML4 buttons, <select>s, <input>s, legends, and floating/compact elements do this.
+    bool sizesToIntrinsicWidth(WidthType) const;
+    virtual bool stretchesToMinIntrinsicWidth() const { return false; }
+
+    int calcWidthUsing(WidthType, int containerWidth);
+    int calcHeightUsing(const Length& height);
+    int calcReplacedWidthUsing(Length width) const;
+    int calcReplacedHeightUsing(Length height) const;
+
+    virtual int calcReplacedWidth(bool includeMaxWidth = true) const;
+    virtual int calcReplacedHeight() const;
+
+    int calcPercentageHeight(const Length& height);
+
+    virtual int availableHeight() const;
+    int availableHeightUsing(const Length&) const;
+
+    void calcVerticalMargins();
+
+    int relativePositionOffsetX() const;
+    int relativePositionOffsetY() const;
+
+    virtual RenderLayer* layer() const { return m_layer; }
+
+    virtual IntRect caretRect(InlineBox*, int caretOffset, int* extraWidthToEndOfLine = 0);
+
+    virtual void paintFillLayerExtended(const PaintInfo&, const Color&, const FillLayer*, int clipY, int clipHeight,
+                                        int tx, int ty, int width, int height, InlineFlowBox* = 0, CompositeOperator = CompositeSourceOver);
+    IntSize calculateBackgroundSize(const FillLayer*, int scaledWidth, int scaledHeight) const;
+
+    virtual int staticX() const;
+    virtual int staticY() const;
+    virtual void setStaticX(int staticX);
+    virtual void setStaticY(int staticY);
+
+    virtual IntRect getOverflowClipRect(int tx, int ty);
+    virtual IntRect getClipRect(int tx, int ty);
+
+    virtual void paintBoxDecorations(PaintInfo&, int tx, int ty);
+    virtual void paintMask(PaintInfo& paintInfo, int tx, int ty);
+    virtual void imageChanged(WrappedImagePtr);
+
+    // Called when a positioned object moves but doesn't change size.  A simplified layout is done
+    // that just updates the object's position.
+    virtual void tryLayoutDoingPositionedMovementOnly()
+    {
+        int oldWidth = m_width;
+        calcWidth();
+        // If we shrink to fit our width may have changed, so we still need full layout.
+        if (oldWidth != m_width)
+            return;
+        calcHeight();
+        setNeedsLayout(false);
+    }
+
+    virtual IntRect maskClipRect();
+    
+protected:
+    virtual void styleWillChange(RenderStyle::Diff, const RenderStyle* newStyle);
+    virtual void styleDidChange(RenderStyle::Diff, const RenderStyle* oldStyle);
+
+    void paintFillLayer(const PaintInfo&, const Color&, const FillLayer*, int clipY, int clipHeight, int tx, int ty, int width, int height, CompositeOperator = CompositeSourceOver);
+    void paintFillLayers(const PaintInfo&, const Color&, const FillLayer*, int clipY, int clipHeight, int tx, int ty, int width, int height, CompositeOperator = CompositeSourceOver);
+
+    void paintMaskImages(const PaintInfo&, int clipY, int clipHeight, int tx, int ty, int width, int height);
+
+#if PLATFORM(MAC)
+    void paintCustomHighlight(int tx, int ty, const AtomicString& type, bool behindText);
+#endif
+
+    void calcAbsoluteHorizontal();
+    
+    virtual bool shouldCalculateSizeAsReplaced() const { return isReplaced() && !isInlineBlockOrInlineTable(); }
+
+private:
+    void paintRootBoxDecorations(PaintInfo&, int tx, int ty);
+    // Returns true if we did a full repaint
+    bool repaintLayerRectsForImage(WrappedImagePtr image, const FillLayer* layers, bool drawingBackground);
+
+    void calculateBackgroundImageGeometry(const FillLayer*, int tx, int ty, int w, int h, IntRect& destRect, IntPoint& phase, IntSize& tileSize);
+    
+    int containingBlockWidthForPositioned(const RenderObject* containingBlock) const;
+    int containingBlockHeightForPositioned(const RenderObject* containingBlock) const;
+
+    void calcAbsoluteVertical();
+    void calcAbsoluteHorizontalValues(Length width, const RenderObject* cb, TextDirection containerDirection,
+                                      int containerWidth, int bordersPlusPadding,
+                                      Length left, Length right, Length marginLeft, Length marginRight,
+                                      int& widthValue, int& marginLeftValue, int& marginRightValue, int& xPos);
+    void calcAbsoluteVerticalValues(Length height, const RenderObject* cb,
+                                    int containerHeight, int bordersPlusPadding,
+                                    Length top, Length bottom, Length marginTop, Length marginBottom,
+                                    int& heightValue, int& marginTopValue, int& marginBottomValue, int& yPos);
+
+    void calcAbsoluteVerticalReplaced();
+    void calcAbsoluteHorizontalReplaced();
+
+    // This function calculates the minimum and maximum preferred widths for an object.
+    // These values are used in shrink-to-fit layout systems.
+    // These include tables, positioned objects, floats and flexible boxes.
+    virtual void calcPrefWidths() = 0;
+
+protected:
+    // The width/height of the contents + borders + padding.
+    int m_width;
+    int m_height;
+
+#ifdef ANDROID_LAYOUT
+    int m_visibleWidth;
+#endif
+
+    int m_x;
+    int m_y;
+
+    int m_marginLeft;
+    int m_marginRight;
+    int m_marginTop;
+    int m_marginBottom;
+
+    // The preferred width of the element if it were to break its lines at every possible opportunity.
+    int m_minPrefWidth;
+    
+    // The preferred width of the element if it never breaks any lines at all.
+    int m_maxPrefWidth;
+
+    // A pointer to our layer if we have one.
+    RenderLayer* m_layer;
+
+    // For inline replaced elements, the inline box that owns us.
+    InlineBox* m_inlineBoxWrapper;
+
+private:
+    // Used to store state between styleWillChange and styleDidChange
+    static bool s_wasFloating;
+    static bool s_hadOverflowClip;
+};
+
+} // namespace WebCore
+
+#endif // RenderBox_h