Changeset 90600 in webkit


Ignore:
Timestamp:
Jul 7, 2011 4:17:55 PM (13 years ago)
Author:
leviw@chromium.org
Message:

Switch remaining paint functions to new layout types
https://bugs.webkit.org/show_bug.cgi?id=64116

Reviewed by Eric Seidel.

Switching all functions with IntPoint paintOffsets to the new Layout types.

No new tests, no functionality changes.

  • rendering/EllipsisBox.cpp:

(WebCore::EllipsisBox::paint):
(WebCore::EllipsisBox::paintSelection):

  • rendering/EllipsisBox.h:
  • rendering/InlineBox.cpp:

(WebCore::InlineBox::paint):

  • rendering/InlineBox.h:
  • rendering/InlineFlowBox.cpp:

(WebCore::InlineFlowBox::paint):

  • rendering/InlineFlowBox.h:
  • rendering/InlineTextBox.cpp:

(WebCore::InlineTextBox::paint):
(WebCore::InlineTextBox::paintCustomHighlight):

  • rendering/InlineTextBox.h:
  • rendering/LayoutTypes.h:
  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::paintColumnRules):
(WebCore::RenderBlock::paintColumnContents):
(WebCore::RenderBlock::paintContents):
(WebCore::RenderBlock::paintChildren):
(WebCore::RenderBlock::paintCaret):
(WebCore::RenderBlock::paintObject):
(WebCore::RenderBlock::paintFloats):
(WebCore::RenderBlock::paintEllipsisBoxes):
(WebCore::RenderBlock::paintContinuationOutlines):
(WebCore::RenderBlock::paintSelection):

  • rendering/RenderBlock.h:
  • rendering/RenderBox.cpp:

(WebCore::RenderBox::paintCustomHighlight):

  • rendering/RenderBox.h:
  • rendering/RenderInline.cpp:

(WebCore::RenderInline::paintOutline):
(WebCore::RenderInline::paintOutlineForLine):

  • rendering/RenderInline.h:
  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::paintOverflowControls):
(WebCore::RenderLayer::paintScrollCorner):
(WebCore::RenderLayer::paintResizer):

  • rendering/RenderLayer.h:
  • rendering/RenderLineBoxList.cpp:

(WebCore::RenderLineBoxList::paint):

  • rendering/RenderListBox.cpp:

(WebCore::RenderListBox::paintScrollbar):
(WebCore::RenderListBox::paintItemForeground):
(WebCore::RenderListBox::paintItemBackground):

  • rendering/RenderListBox.h:
  • rendering/RenderObject.cpp:

(WebCore::RenderObject::paintFocusRing):
(WebCore::RenderObject::paintOutline):

  • rendering/RenderObject.h:
  • rendering/RenderReplaced.cpp:

(WebCore::RenderReplaced::shouldPaint):

  • rendering/RenderReplaced.h:
  • rendering/RenderScrollbarPart.cpp:

(WebCore::RenderScrollbarPart::paintIntoRect):

  • rendering/RenderScrollbarPart.h:
  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::paintBackgroundsBehindCell):

  • rendering/RenderTableSection.cpp:

(WebCore::RenderTableSection::paintCell):

  • rendering/RenderTableSection.h:
  • rendering/RenderTextControl.cpp:

(WebCore::RenderTextControl::paintPlaceholder):

  • rendering/RootInlineBox.cpp:

(WebCore::RootInlineBox::paintEllipsisBox):
(WebCore::RootInlineBox::paintCustomHighlight):
(WebCore::RootInlineBox::paint):

  • rendering/RootInlineBox.h:
  • rendering/mathml/RenderMathMLBlock.cpp:

(WebCore::RenderMathMLBlock::paint):

  • rendering/mathml/RenderMathMLFraction.cpp:

(WebCore::RenderMathMLFraction::paint):

  • rendering/mathml/RenderMathMLRoot.cpp:

(WebCore::RenderMathMLRoot::paint):

  • rendering/mathml/RenderMathMLSquareRoot.cpp:

(WebCore::RenderMathMLSquareRoot::paint):

Location:
trunk/Source/WebCore
Files:
37 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r90599 r90600  
     12011-07-07  Levi Weintraub  <leviw@chromium.org>
     2
     3        Switch remaining paint functions to new layout types
     4        https://bugs.webkit.org/show_bug.cgi?id=64116
     5
     6        Reviewed by Eric Seidel.
     7
     8        Switching all functions with IntPoint paintOffsets to the new Layout types.
     9
     10        No new tests, no functionality changes.
     11
     12        * rendering/EllipsisBox.cpp:
     13        (WebCore::EllipsisBox::paint):
     14        (WebCore::EllipsisBox::paintSelection):
     15        * rendering/EllipsisBox.h:
     16        * rendering/InlineBox.cpp:
     17        (WebCore::InlineBox::paint):
     18        * rendering/InlineBox.h:
     19        * rendering/InlineFlowBox.cpp:
     20        (WebCore::InlineFlowBox::paint):
     21        * rendering/InlineFlowBox.h:
     22        * rendering/InlineTextBox.cpp:
     23        (WebCore::InlineTextBox::paint):
     24        (WebCore::InlineTextBox::paintCustomHighlight):
     25        * rendering/InlineTextBox.h:
     26        * rendering/LayoutTypes.h:
     27        * rendering/RenderBlock.cpp:
     28        (WebCore::RenderBlock::paintColumnRules):
     29        (WebCore::RenderBlock::paintColumnContents):
     30        (WebCore::RenderBlock::paintContents):
     31        (WebCore::RenderBlock::paintChildren):
     32        (WebCore::RenderBlock::paintCaret):
     33        (WebCore::RenderBlock::paintObject):
     34        (WebCore::RenderBlock::paintFloats):
     35        (WebCore::RenderBlock::paintEllipsisBoxes):
     36        (WebCore::RenderBlock::paintContinuationOutlines):
     37        (WebCore::RenderBlock::paintSelection):
     38        * rendering/RenderBlock.h:
     39        * rendering/RenderBox.cpp:
     40        (WebCore::RenderBox::paintCustomHighlight):
     41        * rendering/RenderBox.h:
     42        * rendering/RenderInline.cpp:
     43        (WebCore::RenderInline::paintOutline):
     44        (WebCore::RenderInline::paintOutlineForLine):
     45        * rendering/RenderInline.h:
     46        * rendering/RenderLayer.cpp:
     47        (WebCore::RenderLayer::paintOverflowControls):
     48        (WebCore::RenderLayer::paintScrollCorner):
     49        (WebCore::RenderLayer::paintResizer):
     50        * rendering/RenderLayer.h:
     51        * rendering/RenderLineBoxList.cpp:
     52        (WebCore::RenderLineBoxList::paint):
     53        * rendering/RenderListBox.cpp:
     54        (WebCore::RenderListBox::paintScrollbar):
     55        (WebCore::RenderListBox::paintItemForeground):
     56        (WebCore::RenderListBox::paintItemBackground):
     57        * rendering/RenderListBox.h:
     58        * rendering/RenderObject.cpp:
     59        (WebCore::RenderObject::paintFocusRing):
     60        (WebCore::RenderObject::paintOutline):
     61        * rendering/RenderObject.h:
     62        * rendering/RenderReplaced.cpp:
     63        (WebCore::RenderReplaced::shouldPaint):
     64        * rendering/RenderReplaced.h:
     65        * rendering/RenderScrollbarPart.cpp:
     66        (WebCore::RenderScrollbarPart::paintIntoRect):
     67        * rendering/RenderScrollbarPart.h:
     68        * rendering/RenderTableCell.cpp:
     69        (WebCore::RenderTableCell::paintBackgroundsBehindCell):
     70        * rendering/RenderTableSection.cpp:
     71        (WebCore::RenderTableSection::paintCell):
     72        * rendering/RenderTableSection.h:
     73        * rendering/RenderTextControl.cpp:
     74        (WebCore::RenderTextControl::paintPlaceholder):
     75        * rendering/RootInlineBox.cpp:
     76        (WebCore::RootInlineBox::paintEllipsisBox):
     77        (WebCore::RootInlineBox::paintCustomHighlight):
     78        (WebCore::RootInlineBox::paint):
     79        * rendering/RootInlineBox.h:
     80        * rendering/mathml/RenderMathMLBlock.cpp:
     81        (WebCore::RenderMathMLBlock::paint):
     82        * rendering/mathml/RenderMathMLFraction.cpp:
     83        (WebCore::RenderMathMLFraction::paint):
     84        * rendering/mathml/RenderMathMLRoot.cpp:
     85        (WebCore::RenderMathMLRoot::paint):
     86        * rendering/mathml/RenderMathMLSquareRoot.cpp:
     87        (WebCore::RenderMathMLSquareRoot::paint):
     88
    1892011-07-07  Steve VanDeBogart  <vandebo@chromium.org>
    290
  • trunk/Source/WebCore/rendering/EllipsisBox.cpp

    r90515 r90600  
    3131namespace WebCore {
    3232
    33 void EllipsisBox::paint(PaintInfo& paintInfo, const IntPoint& paintOffset, int lineTop, int lineBottom)
     33void EllipsisBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
    3434{
    3535    GraphicsContext* context = paintInfo.context;
     
    4040    bool setShadow = false;
    4141    if (style->textShadow()) {
    42         context->setShadow(IntSize(style->textShadow()->x(), style->textShadow()->y()),
     42        context->setShadow(LayoutSize(style->textShadow()->x(), style->textShadow()->y()),
    4343                           style->textShadow()->blur(), style->textShadow()->color(), style->colorSpace());
    4444        setShadow = true;
     
    5656
    5757    // FIXME: Why is this always LTR? Fix by passing correct text run flags below.
    58     context->drawText(font, RenderBlock::constructTextRun(renderer(), font, m_str, style, TextRun::AllowTrailingExpansion), IntPoint(x() + paintOffset.x(), y() + paintOffset.y() + style->fontMetrics().ascent()));
     58    context->drawText(font, RenderBlock::constructTextRun(renderer(), font, m_str, style, TextRun::AllowTrailingExpansion), LayoutPoint(x() + paintOffset.x(), y() + paintOffset.y() + style->fontMetrics().ascent()));
    5959
    6060    // Restore the regular fill color.
     
    6767    if (m_markupBox) {
    6868        // Paint the markup box
    69         IntPoint adjustedPaintOffset = paintOffset;
     69        LayoutPoint adjustedPaintOffset = paintOffset;
    7070        adjustedPaintOffset.move(x() + m_logicalWidth - m_markupBox->x(),
    7171            y() + style->fontMetrics().ascent() - (m_markupBox->y() + m_markupBox->renderer()->style(m_firstLine)->fontMetrics().ascent()));
     
    8282}
    8383
    84 void EllipsisBox::paintSelection(GraphicsContext* context, const IntPoint& paintOffset, RenderStyle* style, const Font& font)
     84void EllipsisBox::paintSelection(GraphicsContext* context, const LayoutPoint& paintOffset, RenderStyle* style, const Font& font)
    8585{
    8686    Color textColor = style->visitedDependentColor(CSSPropertyColor);
     
    9595
    9696    GraphicsContextStateSaver stateSaver(*context);
    97     int top = root()->selectionTop();
    98     int h = root()->selectionHeight();
     97    LayoutUnit top = root()->selectionTop();
     98    LayoutUnit h = root()->selectionHeight();
     99    // FIXME: We'll need to apply the correct clip rounding here: https://bugs.webkit.org/show_bug.cgi?id=63656
    99100    context->clip(IntRect(x() + paintOffset.x(), top + paintOffset.y(), m_logicalWidth, h));
    100101    // FIXME: Why is this always LTR? Fix by passing correct text run flags below.
  • trunk/Source/WebCore/rendering/EllipsisBox.h

    r90515 r90600  
    4040    }
    4141
    42     virtual void paint(PaintInfo&, const IntPoint&, int lineTop, int lineBottom);
     42    virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
    4343    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, int lineTop, int lineBottom);
    4444    void setSelectionState(RenderObject::SelectionState s) { m_selectionState = s; }
     
    4848    virtual int height() const { return m_height; }
    4949    virtual RenderObject::SelectionState selectionState() { return m_selectionState; }
    50     void paintSelection(GraphicsContext*, const IntPoint&, RenderStyle*, const Font&);
     50    void paintSelection(GraphicsContext*, const LayoutPoint&, RenderStyle*, const Font&);
    5151
    5252    int m_height;
  • trunk/Source/WebCore/rendering/InlineBox.cpp

    r90515 r90600  
    197197}
    198198
    199 void InlineBox::paint(PaintInfo& paintInfo, const IntPoint& paintOffset, int /* lineTop */, int /*lineBottom*/)
     199void InlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
    200200{
    201201    if (!paintInfo.shouldPaintWithinRoot(renderer()) || (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection))
    202202        return;
    203203
    204     IntPoint childPoint = paintOffset;
     204    LayoutPoint childPoint = paintOffset;
    205205    if (parent()->renderer()->style()->isFlippedBlocksWritingMode()) // Faster than calling containingBlock().
    206206        childPoint = renderer()->containingBlock()->flipForWritingMode(toRenderBox(renderer()), childPoint, RenderBox::ParentToChildFlippingAdjustment);
  • trunk/Source/WebCore/rendering/InlineBox.h

    r90515 r90600  
    127127    }
    128128
    129     virtual void paint(PaintInfo&, const IntPoint&, int lineTop, int lineBottom);
     129    virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
    130130    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, int lineTop, int lineBottom);
    131131
  • trunk/Source/WebCore/rendering/InlineFlowBox.cpp

    r90515 r90600  
    947947}
    948948
    949 void InlineFlowBox::paint(PaintInfo& paintInfo, const IntPoint& paintOffset, int lineTop, int lineBottom)
    950 {
    951     IntRect overflowRect(visualOverflowRect(lineTop, lineBottom));
     949void InlineFlowBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
     950{
     951    LayoutRect overflowRect(visualOverflowRect(lineTop, lineBottom));
    952952    overflowRect.inflate(renderer()->maximalOutlineSize(paintInfo.phase));
    953953    flipForWritingMode(overflowRect);
  • trunk/Source/WebCore/rendering/InlineFlowBox.h

    r90517 r90600  
    109109    void paintFillLayer(const PaintInfo&, const Color&, const FillLayer*, const LayoutRect&, CompositeOperator = CompositeSourceOver);
    110110    void paintBoxShadow(GraphicsContext*, RenderStyle*, ShadowStyle, const LayoutRect&);
    111     virtual void paint(PaintInfo&, const IntPoint&, int lineTop, int lineBottom);
     111    virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
    112112    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, int lineTop, int lineBottom);
    113113
  • trunk/Source/WebCore/rendering/InlineTextBox.cpp

    r90596 r90600  
    467467}
    468468
    469 void InlineTextBox::paint(PaintInfo& paintInfo, const IntPoint& paintOffset, int /*lineTop*/, int /*lineBottom*/)
     469void InlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/)
    470470{
    471471    if (isLineBreak() || !paintInfo.shouldPaintWithinRoot(renderer()) || renderer()->style()->visibility() != VISIBLE ||
     
    475475    ASSERT(paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines);
    476476
    477     int logicalLeftSide = logicalLeftVisualOverflow();
    478     int logicalRightSide = logicalRightVisualOverflow();
    479     int logicalStart = logicalLeftSide + (isHorizontal() ? paintOffset.x() : paintOffset.y());
    480     int logicalExtent = logicalRightSide - logicalLeftSide;
    481    
    482     int paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
    483     int paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
    484    
    485     IntPoint adjustedPaintOffset = paintOffset;
     477    LayoutUnit logicalLeftSide = logicalLeftVisualOverflow();
     478    LayoutUnit logicalRightSide = logicalRightVisualOverflow();
     479    LayoutUnit logicalStart = logicalLeftSide + (isHorizontal() ? paintOffset.x() : paintOffset.y());
     480    LayoutUnit logicalExtent = logicalRightSide - logicalLeftSide;
     481   
     482    LayoutUnit paintEnd = isHorizontal() ? paintInfo.rect.maxX() : paintInfo.rect.maxY();
     483    LayoutUnit paintStart = isHorizontal() ? paintInfo.rect.x() : paintInfo.rect.y();
     484   
     485    LayoutPoint adjustedPaintOffset = paintOffset;
    486486   
    487487    if (logicalStart >= paintEnd || logicalStart + logicalExtent <= paintStart)
     
    506506            // NOTE: WebKit's behavior differs from that of IE which appears to just overlay the ellipsis on top of the
    507507            // truncated string i.e.  |Hello|CBA| -> |...lo|CBA|
    508             int widthOfVisibleText = toRenderText(renderer())->width(m_start, m_truncation, textPos(), m_firstLine);
    509             int widthOfHiddenText = m_logicalWidth - widthOfVisibleText;
    510             // FIXME: The hit testing logic also needs to take this translation int account.
    511             IntSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0);
     508            LayoutUnit widthOfVisibleText = toRenderText(renderer())->width(m_start, m_truncation, textPos(), m_firstLine);
     509            LayoutUnit widthOfHiddenText = m_logicalWidth - widthOfVisibleText;
     510            // FIXME: The hit testing logic also needs to take this translation into account.
     511            LayoutSize truncationOffset(isLeftToRightDirection() ? widthOfHiddenText : -widthOfHiddenText, 0);
    512512            adjustedPaintOffset.move(isHorizontal() ? truncationOffset : truncationOffset.transposedSize());
    513513        }
     
    522522    FloatPoint boxOrigin = locationIncludingFlipping();
    523523    boxOrigin.move(adjustedPaintOffset.x(), adjustedPaintOffset.y());
    524     FloatRect boxRect(boxOrigin, IntSize(logicalWidth(), logicalHeight()));
     524    FloatRect boxRect(boxOrigin, LayoutSize(logicalWidth(), logicalHeight()));
    525525
    526526    RenderCombineText* combinedText = styleToUse->hasTextCombine() && textRenderer()->isCombineText() && toRenderCombineText(textRenderer())->isCombined() ? toRenderCombineText(textRenderer()) : 0;
     
    854854#if PLATFORM(MAC)
    855855
    856 void InlineTextBox::paintCustomHighlight(const IntPoint& paintOffset, const AtomicString& type)
     856void InlineTextBox::paintCustomHighlight(const LayoutPoint& paintOffset, const AtomicString& type)
    857857{
    858858    Frame* frame = renderer()->frame();
  • trunk/Source/WebCore/rendering/InlineTextBox.h

    r90596 r90600  
    111111
    112112protected:
    113     virtual void paint(PaintInfo&, const IntPoint&, int lineTop, int lineBottom);
    114     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, int lineTop, int lineBottom);
     113    virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
     114    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom);
    115115
    116116public:
     
    170170    void paintCompositionUnderline(GraphicsContext*, const FloatPoint& boxOrigin, const CompositionUnderline&);
    171171#if PLATFORM(MAC)
    172     void paintCustomHighlight(const IntPoint&, const AtomicString& type);
     172    void paintCustomHighlight(const LayoutPoint&, const AtomicString& type);
    173173#endif
    174174
  • trunk/Source/WebCore/rendering/LayoutTypes.h

    r90590 r90600  
    3737#define LayoutTypes_h
    3838
    39 #include "FloatPoint.h"
    4039#include "FloatRect.h"
    4140#include "IntRect.h"
  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r90596 r90600  
    22942294}
    22952295
    2296 void RenderBlock::paintColumnRules(PaintInfo& paintInfo, const IntPoint& paintOffset)
     2296void RenderBlock::paintColumnRules(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    22972297{
    22982298    if (paintInfo.context->paintingDisabled())
     
    23022302    bool ruleTransparent = style()->columnRuleIsTransparent();
    23032303    EBorderStyle ruleStyle = style()->columnRuleStyle();
    2304     int ruleWidth = style()->columnRuleWidth();
    2305     int colGap = columnGap();
     2304    LayoutUnit ruleWidth = style()->columnRuleWidth();
     2305    LayoutUnit colGap = columnGap();
    23062306    bool renderRule = ruleStyle > BHIDDEN && !ruleTransparent && ruleWidth <= colGap;
    23072307    if (!renderRule)
     
    23112311    ColumnInfo* colInfo = columnInfo();
    23122312    unsigned colCount = columnCount(colInfo);
    2313     int currLogicalLeftOffset = style()->isLeftToRightDirection() ? 0 : contentLogicalWidth();
    2314     int ruleAdd = logicalLeftOffsetForContent();
    2315     int ruleLogicalLeft = style()->isLeftToRightDirection() ? 0 : contentLogicalWidth();
     2313    LayoutUnit currLogicalLeftOffset = style()->isLeftToRightDirection() ? 0 : contentLogicalWidth();
     2314    LayoutUnit ruleAdd = logicalLeftOffsetForContent();
     2315    LayoutUnit ruleLogicalLeft = style()->isLeftToRightDirection() ? 0 : contentLogicalWidth();
    23162316
    23172317    const AffineTransform& currentCTM = paintInfo.context->getCTM();
     
    23212321        LayoutRect colRect = columnRectAt(colInfo, i);
    23222322
    2323         int inlineDirectionSize = isHorizontalWritingMode() ? colRect.width() : colRect.height();
     2323        LayoutUnit inlineDirectionSize = isHorizontalWritingMode() ? colRect.width() : colRect.height();
    23242324       
    23252325        // Move to the next position.
     
    23342334        // Now paint the column rule.
    23352335        if (i < colCount - 1) {
    2336             int ruleLeft = isHorizontalWritingMode() ? paintOffset.x() + ruleLogicalLeft - ruleWidth / 2 + ruleAdd : paintOffset.x() + borderBefore() + paddingBefore();
    2337             int ruleRight = isHorizontalWritingMode() ? ruleLeft + ruleWidth : ruleLeft + contentWidth();
    2338             int ruleTop = isHorizontalWritingMode() ? paintOffset.y() + borderTop() + paddingTop() : paintOffset.y() + ruleLogicalLeft - ruleWidth / 2 + ruleAdd;
    2339             int ruleBottom = isHorizontalWritingMode() ? ruleTop + contentHeight() : ruleTop + ruleWidth;
     2336            LayoutUnit ruleLeft = isHorizontalWritingMode() ? paintOffset.x() + ruleLogicalLeft - ruleWidth / 2 + ruleAdd : paintOffset.x() + borderBefore() + paddingBefore();
     2337            LayoutUnit ruleRight = isHorizontalWritingMode() ? ruleLeft + ruleWidth : ruleLeft + contentWidth();
     2338            LayoutUnit ruleTop = isHorizontalWritingMode() ? paintOffset.y() + borderTop() + paddingTop() : paintOffset.y() + ruleLogicalLeft - ruleWidth / 2 + ruleAdd;
     2339            LayoutUnit ruleBottom = isHorizontalWritingMode() ? ruleTop + contentHeight() : ruleTop + ruleWidth;
    23402340            drawLineForBoxSide(paintInfo.context, ruleLeft, ruleTop, ruleRight, ruleBottom,
    23412341                               style()->isLeftToRightDirection() ? BSLeft : BSRight, ruleColor, ruleStyle, 0, 0, antialias);
     
    23462346}
    23472347
    2348 void RenderBlock::paintColumnContents(PaintInfo& paintInfo, const IntPoint& paintOffset, bool paintingFloats)
     2348void RenderBlock::paintColumnContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset, bool paintingFloats)
    23492349{
    23502350    // We need to do multiple passes, breaking up our child painting into strips.
     
    23542354    if (!colCount)
    23552355        return;
    2356     int currLogicalTopOffset = 0;
     2356    LayoutUnit currLogicalTopOffset = 0;
    23572357    for (unsigned i = 0; i < colCount; i++) {
    23582358        // For each rect, we clip to the rect, and then we adjust our coords.
    23592359        LayoutRect colRect = columnRectAt(colInfo, i);
    23602360        flipForWritingMode(colRect);
    2361         int logicalLeftOffset = (isHorizontalWritingMode() ? colRect.x() : colRect.y()) - logicalLeftOffsetForContent();
    2362         IntSize offset = isHorizontalWritingMode() ? IntSize(logicalLeftOffset, currLogicalTopOffset) : IntSize(currLogicalTopOffset, logicalLeftOffset);
     2361        LayoutUnit logicalLeftOffset = (isHorizontalWritingMode() ? colRect.x() : colRect.y()) - logicalLeftOffsetForContent();
     2362        LayoutSize offset = isHorizontalWritingMode() ? LayoutSize(logicalLeftOffset, currLogicalTopOffset) : LayoutSize(currLogicalTopOffset, logicalLeftOffset);
    23632363        colRect.moveBy(paintOffset);
    23642364        PaintInfo info(paintInfo);
     
    23732373
    23742374            // Adjust our x and y when painting.
    2375             IntPoint adjustedPaintOffset = paintOffset + offset;
     2375            LayoutPoint adjustedPaintOffset = paintOffset + offset;
    23762376            if (paintingFloats)
    23772377                paintFloats(info, adjustedPaintOffset, paintInfo.phase == PaintPhaseSelection || paintInfo.phase == PaintPhaseTextClip);
     
    23802380        }
    23812381
    2382         int blockDelta = (isHorizontalWritingMode() ? colRect.height() : colRect.width());
     2382        LayoutUnit blockDelta = (isHorizontalWritingMode() ? colRect.height() : colRect.width());
    23832383        if (style()->isFlippedBlocksWritingMode())
    23842384            currLogicalTopOffset += blockDelta;
     
    23882388}
    23892389
    2390 void RenderBlock::paintContents(PaintInfo& paintInfo, const IntPoint& paintOffset)
     2390void RenderBlock::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    23912391{
    23922392    // Avoid painting descendants of the root element when stylesheets haven't loaded.  This eliminates FOUC.
     
    24022402}
    24032403
    2404 void RenderBlock::paintChildren(PaintInfo& paintInfo, const IntPoint& paintOffset)
     2404void RenderBlock::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    24052405{
    24062406    PaintPhase newPhase = (paintInfo.phase == PaintPhaseChildOutlines) ? PaintPhaseOutline : paintInfo.phase;
     
    24202420        // Check for page-break-before: always, and if it's set, break and bail.
    24212421        bool checkBeforeAlways = !childrenInline() && (usePrintRect && child->style()->pageBreakBefore() == PBALWAYS);
    2422         int absoluteChildY = paintOffset.y() + child->y();
     2422        LayoutUnit absoluteChildY = paintOffset.y() + child->y();
    24232423        if (checkBeforeAlways
    24242424            && absoluteChildY > paintInfo.rect.y()
     
    24392439        }
    24402440
    2441         IntPoint childPoint = flipForWritingMode(child, paintOffset, ParentToChildFlippingAdjustment);
     2441        LayoutPoint childPoint = flipForWritingMode(child, paintOffset, ParentToChildFlippingAdjustment);
    24422442        if (!child->hasSelfPaintingLayer() && !child->isFloating())
    24432443            child->paint(info, childPoint);
     
    24542454}
    24552455
    2456 void RenderBlock::paintCaret(PaintInfo& paintInfo, const IntPoint& paintOffset, CaretType type)
     2456void RenderBlock::paintCaret(PaintInfo& paintInfo, const LayoutPoint& paintOffset, CaretType type)
    24572457{
    24582458    // Paint the caret if the FrameSelection says so or if caret browsing is enabled
     
    24712471        // Convert the painting offset into the local coordinate system of this renderer,
    24722472        // to match the localCaretRect computed by the FrameSelection
    2473         IntPoint adjustedPaintOffset = paintOffset;
     2473        LayoutPoint adjustedPaintOffset = paintOffset;
    24742474        offsetForContents(adjustedPaintOffset);
    24752475
     
    25312531    // 5. paint outline.
    25322532    if ((paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseSelfOutline) && hasOutline() && style()->visibility() == VISIBLE)
    2533         paintOutline(paintInfo.context, IntRect(paintOffset, size()));
     2533        paintOutline(paintInfo.context, LayoutRect(paintOffset, size()));
    25342534
    25352535    // 6. paint continuation outlines.
     
    25782578}
    25792579
    2580 void RenderBlock::paintFloats(PaintInfo& paintInfo, const IntPoint& paintOffset, bool preservePhase)
     2580void RenderBlock::paintFloats(PaintInfo& paintInfo, const LayoutPoint& paintOffset, bool preservePhase)
    25812581{
    25822582    if (!m_floatingObjects)
     
    25912591            PaintInfo currentPaintInfo(paintInfo);
    25922592            currentPaintInfo.phase = preservePhase ? paintInfo.phase : PaintPhaseBlockBackground;
    2593             IntPoint childPoint = flipFloatForWritingMode(r, IntPoint(paintOffset.x() + xPositionForFloatIncludingMargin(r) - r->m_renderer->x(), paintOffset.y() + yPositionForFloatIncludingMargin(r) - r->m_renderer->y()));
     2593            LayoutPoint childPoint = flipFloatForWritingMode(r, LayoutPoint(paintOffset.x() + xPositionForFloatIncludingMargin(r) - r->m_renderer->x(), paintOffset.y() + yPositionForFloatIncludingMargin(r) - r->m_renderer->y()));
    25942594            r->m_renderer->paint(currentPaintInfo, childPoint);
    25952595            if (!preservePhase) {
     
    26072607}
    26082608
    2609 void RenderBlock::paintEllipsisBoxes(PaintInfo& paintInfo, const IntPoint& paintOffset)
     2609void RenderBlock::paintEllipsisBoxes(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    26102610{
    26112611    if (!paintInfo.shouldPaintWithinRoot(this) || !firstLineBox())
     
    26152615        // We can check the first box and last box and avoid painting if we don't
    26162616        // intersect.
    2617         int yPos = paintOffset.y() + firstLineBox()->y();
    2618         int h = lastLineBox()->y() + lastLineBox()->logicalHeight() - firstLineBox()->y();
     2617        LayoutUnit yPos = paintOffset.y() + firstLineBox()->y();
     2618        LayoutUnit h = lastLineBox()->y() + lastLineBox()->logicalHeight() - firstLineBox()->y();
    26192619        if (yPos >= paintInfo.rect.maxY() || yPos + h <= paintInfo.rect.y())
    26202620            return;
     
    26842684}
    26852685
    2686 void RenderBlock::paintContinuationOutlines(PaintInfo& info, const IntPoint& paintOffset)
     2686void RenderBlock::paintContinuationOutlines(PaintInfo& info, const LayoutPoint& paintOffset)
    26872687{
    26882688    ContinuationOutlineTableMap* table = continuationOutlineTable();
     
    26942694        return;
    26952695
    2696     IntPoint accumulatedPaintOffset = paintOffset;
     2696    LayoutPoint accumulatedPaintOffset = paintOffset;
    26972697    // Paint each continuation outline.
    26982698    ListHashSet<RenderInline*>::iterator end = continuations->end();
     
    27622762}
    27632763
    2764 void RenderBlock::paintSelection(PaintInfo& paintInfo, const IntPoint& paintOffset)
     2764void RenderBlock::paintSelection(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    27652765{
    27662766    if (shouldPaintSelectionGaps() && paintInfo.phase == PaintPhaseForeground) {
    2767         int lastTop = 0;
    2768         int lastLeft = logicalLeftSelectionOffset(this, lastTop);
    2769         int lastRight = logicalRightSelectionOffset(this, lastTop);
     2767        LayoutUnit lastTop = 0;
     2768        LayoutUnit lastLeft = logicalLeftSelectionOffset(this, lastTop);
     2769        LayoutUnit lastRight = logicalRightSelectionOffset(this, lastTop);
    27702770        GraphicsContextStateSaver stateSaver(*paintInfo.context);
    27712771
    2772         IntRect gapRectsBounds = selectionGaps(this, paintOffset, IntSize(), lastTop, lastLeft, lastRight, &paintInfo);
     2772        LayoutRect gapRectsBounds = selectionGaps(this, paintOffset, LayoutSize(), lastTop, lastLeft, lastRight, &paintInfo);
    27732773        if (!gapRectsBounds.isEmpty()) {
    27742774            if (RenderLayer* layer = enclosingLayer()) {
    27752775                gapRectsBounds.moveBy(-paintOffset);
    27762776                if (!hasLayer()) {
    2777                     IntRect localBounds(gapRectsBounds);
     2777                    LayoutRect localBounds(gapRectsBounds);
    27782778                    flipForWritingMode(localBounds);
    27792779                    gapRectsBounds = localToContainerQuad(FloatRect(localBounds), layer->renderer()).enclosingBoundingBox();
  • trunk/Source/WebCore/rendering/RenderBlock.h

    r90596 r90600  
    563563    // End of functions defined in RenderBlockLineLayout.cpp.
    564564
    565     void paintFloats(PaintInfo&, const IntPoint&, bool preservePhase = false);
    566     void paintContents(PaintInfo&, const IntPoint&);
    567     void paintColumnContents(PaintInfo&, const IntPoint&, bool paintFloats = false);
    568     void paintColumnRules(PaintInfo&, const IntPoint&);
    569     void paintChildren(PaintInfo&, const IntPoint&);
    570     void paintEllipsisBoxes(PaintInfo&, const IntPoint&);
    571     void paintSelection(PaintInfo&, const IntPoint&);
    572     void paintCaret(PaintInfo&, const IntPoint&, CaretType);
     565    void paintFloats(PaintInfo&, const LayoutPoint&, bool preservePhase = false);
     566    void paintContents(PaintInfo&, const LayoutPoint&);
     567    void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
     568    void paintColumnRules(PaintInfo&, const LayoutPoint&);
     569    void paintChildren(PaintInfo&, const LayoutPoint&);
     570    void paintEllipsisBoxes(PaintInfo&, const LayoutPoint&);
     571    void paintSelection(PaintInfo&, const LayoutPoint&);
     572    void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
    573573
    574574    FloatingObject* insertFloatingObject(RenderBox*);
  • trunk/Source/WebCore/rendering/RenderBox.cpp

    r90590 r90600  
    10801080#if PLATFORM(MAC)
    10811081
    1082 void RenderBox::paintCustomHighlight(const IntPoint& paintOffset, const AtomicString& type, bool behindText)
     1082void RenderBox::paintCustomHighlight(const LayoutPoint& paintOffset, const AtomicString& type, bool behindText)
    10831083{
    10841084    Frame* frame = this->frame();
  • trunk/Source/WebCore/rendering/RenderBox.h

    r90590 r90600  
    421421
    422422#if PLATFORM(MAC)
    423     void paintCustomHighlight(const IntPoint&, const AtomicString& type, bool behindText);
     423    void paintCustomHighlight(const LayoutPoint&, const AtomicString& type, bool behindText);
    424424#endif
    425425
  • trunk/Source/WebCore/rendering/RenderInline.cpp

    r90590 r90600  
    13641364}
    13651365
    1366 void RenderInline::paintOutline(GraphicsContext* graphicsContext, const IntPoint& paintOffset)
     1366void RenderInline::paintOutline(GraphicsContext* graphicsContext, const LayoutPoint& paintOffset)
    13671367{
    13681368    if (!hasOutline())
     
    13831383        return;
    13841384
    1385     Vector<IntRect> rects;
    1386 
    1387     rects.append(IntRect());
     1385    Vector<LayoutRect> rects;
     1386
     1387    rects.append(LayoutRect());
    13881388    for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
    13891389        RootInlineBox* root = curr->root();
    1390         int top = max(root->lineTop(), curr->logicalTop());
    1391         int bottom = min(root->lineBottom(), curr->logicalBottom());
    1392         rects.append(IntRect(curr->x(), top, curr->logicalWidth(), bottom - top));
    1393     }
    1394     rects.append(IntRect());
     1390        LayoutUnit top = max(root->lineTop(), curr->logicalTop());
     1391        LayoutUnit bottom = min(root->lineBottom(), curr->logicalBottom());
     1392        rects.append(LayoutRect(curr->x(), top, curr->logicalWidth(), bottom - top));
     1393    }
     1394    rects.append(LayoutRect());
    13951395
    13961396    Color outlineColor = styleToUse->visitedDependentColor(CSSPropertyOutlineColor);
     
    14161416}
    14171417
    1418 void RenderInline::paintOutlineForLine(GraphicsContext* graphicsContext, const IntPoint& paintOffset,
    1419                                        const IntRect& lastline, const IntRect& thisline, const IntRect& nextline,
     1418void RenderInline::paintOutlineForLine(GraphicsContext* graphicsContext, const LayoutPoint& paintOffset,
     1419                                       const LayoutRect& lastline, const LayoutRect& thisline, const LayoutRect& nextline,
    14201420                                       const Color outlineColor)
    14211421{
    14221422    RenderStyle* styleToUse = style();
    1423     int ow = styleToUse->outlineWidth();
    1424     EBorderStyle os = styleToUse->outlineStyle();
     1423    LayoutUnit outlineWidth = styleToUse->outlineWidth();
     1424    EBorderStyle outlineStyle = styleToUse->outlineStyle();
    14251425
    14261426    const AffineTransform& currentCTM = graphicsContext->getCTM();
    14271427    bool antialias = !currentCTM.isIdentityOrTranslationOrFlipped();
    14281428
    1429     int offset = style()->outlineOffset();
    1430 
    1431     int t = paintOffset.y() + thisline.y() - offset;
    1432     int l = paintOffset.x() + thisline.x() - offset;
    1433     int b = paintOffset.y() + thisline.maxY() + offset;
    1434     int r = paintOffset.x() + thisline.maxX() + offset;
     1429    LayoutUnit offset = style()->outlineOffset();
     1430
     1431    LayoutUnit top = paintOffset.y() + thisline.y() - offset;
     1432    LayoutUnit left = paintOffset.x() + thisline.x() - offset;
     1433    LayoutUnit bottom = paintOffset.y() + thisline.maxY() + offset;
     1434    LayoutUnit right = paintOffset.x() + thisline.maxX() + offset;
    14351435   
    14361436    // left edge
    14371437    drawLineForBoxSide(graphicsContext,
    1438                l - ow,
    1439                t - (lastline.isEmpty() || thisline.x() < lastline.x() || (lastline.maxX() - 1) <= thisline.x() ? ow : 0),
    1440                l,
    1441                b + (nextline.isEmpty() || thisline.x() <= nextline.x() || (nextline.maxX() - 1) <= thisline.x() ? ow : 0),
    1442                BSLeft,
    1443                outlineColor, os,
    1444                (lastline.isEmpty() || thisline.x() < lastline.x() || (lastline.maxX() - 1) <= thisline.x() ? ow : -ow),
    1445                (nextline.isEmpty() || thisline.x() <= nextline.x() || (nextline.maxX() - 1) <= thisline.x() ? ow : -ow),
    1446                antialias);
     1438        left - outlineWidth,
     1439        top - (lastline.isEmpty() || thisline.x() < lastline.x() || (lastline.maxX() - 1) <= thisline.x() ? outlineWidth : 0),
     1440        left,
     1441        bottom + (nextline.isEmpty() || thisline.x() <= nextline.x() || (nextline.maxX() - 1) <= thisline.x() ? outlineWidth : 0),
     1442        BSLeft,
     1443        outlineColor, outlineStyle,
     1444        (lastline.isEmpty() || thisline.x() < lastline.x() || (lastline.maxX() - 1) <= thisline.x() ? outlineWidth : -outlineWidth),
     1445        (nextline.isEmpty() || thisline.x() <= nextline.x() || (nextline.maxX() - 1) <= thisline.x() ? outlineWidth : -outlineWidth),
     1446        antialias);
    14471447   
    14481448    // right edge
    14491449    drawLineForBoxSide(graphicsContext,
    1450                r,
    1451                t - (lastline.isEmpty() || lastline.maxX() < thisline.maxX() || (thisline.maxX() - 1) <= lastline.x() ? ow : 0),
    1452                r + ow,
    1453                b + (nextline.isEmpty() || nextline.maxX() <= thisline.maxX() || (thisline.maxX() - 1) <= nextline.x() ? ow : 0),
    1454                BSRight,
    1455                outlineColor, os,
    1456                (lastline.isEmpty() || lastline.maxX() < thisline.maxX() || (thisline.maxX() - 1) <= lastline.x() ? ow : -ow),
    1457                (nextline.isEmpty() || nextline.maxX() <= thisline.maxX() || (thisline.maxX() - 1) <= nextline.x() ? ow : -ow),
    1458                antialias);
     1450        right,
     1451        top - (lastline.isEmpty() || lastline.maxX() < thisline.maxX() || (thisline.maxX() - 1) <= lastline.x() ? outlineWidth : 0),
     1452        right + outlineWidth,
     1453        bottom + (nextline.isEmpty() || nextline.maxX() <= thisline.maxX() || (thisline.maxX() - 1) <= nextline.x() ? outlineWidth : 0),
     1454        BSRight,
     1455        outlineColor, outlineStyle,
     1456        (lastline.isEmpty() || lastline.maxX() < thisline.maxX() || (thisline.maxX() - 1) <= lastline.x() ? outlineWidth : -outlineWidth),
     1457        (nextline.isEmpty() || nextline.maxX() <= thisline.maxX() || (thisline.maxX() - 1) <= nextline.x() ? outlineWidth : -outlineWidth),
     1458        antialias);
    14591459    // upper edge
    14601460    if (thisline.x() < lastline.x())
    14611461        drawLineForBoxSide(graphicsContext,
    1462                    l - ow,
    1463                    t - ow,
    1464                    min(r+ow, (lastline.isEmpty() ? 1000000 : paintOffset.x() + lastline.x())),
    1465                    t,
    1466                    BSTop, outlineColor, os,
    1467                    ow,
    1468                    (!lastline.isEmpty() && paintOffset.x() + lastline.x() + 1 < r + ow) ? -ow : ow,
    1469                    antialias);
     1462            left - outlineWidth,
     1463            top - outlineWidth,
     1464            min(right + outlineWidth, (lastline.isEmpty() ? 1000000 : paintOffset.x() + lastline.x())),
     1465            top,
     1466            BSTop, outlineColor, outlineStyle,
     1467            outlineWidth,
     1468            (!lastline.isEmpty() && paintOffset.x() + lastline.x() + 1 < right + outlineWidth) ? -outlineWidth : outlineWidth,
     1469            antialias);
    14701470   
    14711471    if (lastline.maxX() < thisline.maxX())
    14721472        drawLineForBoxSide(graphicsContext,
    1473                    max(lastline.isEmpty() ? -1000000 : paintOffset.x() + lastline.maxX(), l - ow),
    1474                    t - ow,
    1475                    r + ow,
    1476                    t,
    1477                    BSTop, outlineColor, os,
    1478                    (!lastline.isEmpty() && l - ow < paintOffset.x() + lastline.maxX()) ? -ow : ow,
    1479                    ow, antialias);
     1473            max(lastline.isEmpty() ? -1000000 : paintOffset.x() + lastline.maxX(), left - outlineWidth),
     1474            top - outlineWidth,
     1475            right + outlineWidth,
     1476            top,
     1477            BSTop, outlineColor, outlineStyle,
     1478            (!lastline.isEmpty() && left - outlineWidth < paintOffset.x() + lastline.maxX()) ? -outlineWidth : outlineWidth,
     1479            outlineWidth, antialias);
    14801480   
    14811481    // lower edge
    14821482    if (thisline.x() < nextline.x())
    14831483        drawLineForBoxSide(graphicsContext,
    1484                    l - ow,
    1485                    b,
    1486                    min(r + ow, !nextline.isEmpty() ? paintOffset.x() + nextline.x() + 1 : 1000000),
    1487                    b + ow,
    1488                    BSBottom, outlineColor, os,
    1489                    ow,
    1490                    (!nextline.isEmpty() && paintOffset.x() + nextline.x() + 1 < r + ow) ? -ow : ow,
    1491                    antialias);
     1484            left - outlineWidth,
     1485            bottom,
     1486            min(right + outlineWidth, !nextline.isEmpty() ? paintOffset.x() + nextline.x() + 1 : 1000000),
     1487            bottom + outlineWidth,
     1488            BSBottom, outlineColor, outlineStyle,
     1489            outlineWidth,
     1490            (!nextline.isEmpty() && paintOffset.x() + nextline.x() + 1 < right + outlineWidth) ? -outlineWidth : outlineWidth,
     1491            antialias);
    14921492   
    14931493    if (nextline.maxX() < thisline.maxX())
    14941494        drawLineForBoxSide(graphicsContext,
    1495                    max(!nextline.isEmpty() ? paintOffset.x() + nextline.maxX() : -1000000, l - ow),
    1496                    b,
    1497                    r + ow,
    1498                    b + ow,
    1499                    BSBottom, outlineColor, os,
    1500                    (!nextline.isEmpty() && l - ow < paintOffset.x() + nextline.maxX()) ? -ow : ow,
    1501                    ow, antialias);
     1495            max(!nextline.isEmpty() ? paintOffset.x() + nextline.maxX() : -1000000, left - outlineWidth),
     1496            bottom,
     1497            right + outlineWidth,
     1498            bottom + outlineWidth,
     1499            BSBottom, outlineColor, outlineStyle,
     1500            (!nextline.isEmpty() && left - outlineWidth < paintOffset.x() + nextline.maxX()) ? -outlineWidth : outlineWidth,
     1501            outlineWidth, antialias);
    15021502}
    15031503
  • trunk/Source/WebCore/rendering/RenderInline.h

    r90590 r90600  
    7777
    7878    virtual void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint&);
    79     void paintOutline(GraphicsContext*, const IntPoint&);
     79    void paintOutline(GraphicsContext*, const LayoutPoint&);
    8080
    8181    using RenderBoxModelObject::continuation;
     
    163163    static RenderInline* cloneInline(RenderInline* src);
    164164
    165     void paintOutlineForLine(GraphicsContext*, const IntPoint&, const IntRect& prevLine, const IntRect& thisLine,
    166                              const IntRect& nextLine, const Color);
     165    void paintOutlineForLine(GraphicsContext*, const LayoutPoint&, const LayoutRect& prevLine, const LayoutRect& thisLine,
     166                             const LayoutRect& nextLine, const Color);
    167167    RenderBoxModelObject* continuationBefore(RenderObject* beforeChild);
    168168
  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r90485 r90600  
    22802280}
    22812281
    2282 void RenderLayer::paintOverflowControls(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect, bool paintingOverlayControls)
     2282void RenderLayer::paintOverflowControls(GraphicsContext* context, const LayoutPoint& paintOffset, const IntRect& damageRect, bool paintingOverlayControls)
    22832283{
    22842284    // Don't do anything if we have no overflow.
     
    23042304        return;
    23052305
    2306     IntPoint adjustedPaintOffset = paintOffset;
     2306    LayoutPoint adjustedPaintOffset = paintOffset;
    23072307    if (paintingOverlayControls)
    23082308        adjustedPaintOffset = m_cachedOverlayScrollbarOffset;
     
    23402340}
    23412341
    2342 void RenderLayer::paintScrollCorner(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect)
     2342void RenderLayer::paintScrollCorner(GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& damageRect)
    23432343{
    23442344    RenderBox* box = renderBox();
    23452345    ASSERT(box);
    23462346
    2347     IntRect absRect = scrollCornerRect();
     2347    LayoutRect absRect = scrollCornerRect();
    23482348    absRect.moveBy(paintOffset);
    23492349    if (!absRect.intersects(damageRect))
     
    23662366}
    23672367
    2368 void RenderLayer::paintResizer(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect)
     2368void RenderLayer::paintResizer(GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& damageRect)
    23692369{
    23702370    if (renderer()->style()->resize() == RESIZE_NONE)
     
    23742374    ASSERT(box);
    23752375
    2376     IntRect absRect = resizerCornerRect(this, box->borderBoxRect());
     2376    LayoutRect absRect = resizerCornerRect(this, box->borderBoxRect());
    23772377    absRect.moveBy(paintOffset);
    23782378    if (!absRect.intersects(damageRect))
     
    23912391    // Paint the resizer control.
    23922392    DEFINE_STATIC_LOCAL(RefPtr<Image>, resizeCornerImage, (Image::loadPlatformResource("textAreaResizeCorner")));
    2393     IntPoint imagePoint(absRect.maxX() - resizeCornerImage->width(), absRect.maxY() - resizeCornerImage->height());
     2393    LayoutPoint imagePoint(absRect.maxX() - resizeCornerImage->width(), absRect.maxY() - resizeCornerImage->height());
    23942394    context->drawImage(resizeCornerImage.get(), box->style()->colorSpace(), imagePoint);
    23952395
     
    23992399        GraphicsContextStateSaver stateSaver(*context);
    24002400        context->clip(absRect);
    2401         IntRect largerCorner = absRect;
    2402         largerCorner.setSize(IntSize(largerCorner.width() + 1, largerCorner.height() + 1));
     2401        LayoutRect largerCorner = absRect;
     2402        largerCorner.setSize(LayoutSize(largerCorner.width() + 1, largerCorner.height() + 1));
    24032403        context->setStrokeColor(Color(makeRGB(217, 217, 217)), ColorSpaceDeviceRGB);
    24042404        context->setStrokeThickness(1.0f);
  • trunk/Source/WebCore/rendering/RenderLayer.h

    r90485 r90600  
    270270    LayoutSize offsetFromResizeCorner(const LayoutPoint& absolutePoint) const;
    271271
    272     void paintOverflowControls(GraphicsContext*, const IntPoint&, const IntRect& damageRect, bool paintingOverlayControls = false);
    273     void paintScrollCorner(GraphicsContext*, const IntPoint&, const IntRect& damageRect);
    274     void paintResizer(GraphicsContext*, const IntPoint&, const IntRect& damageRect);
     272    void paintOverflowControls(GraphicsContext*, const LayoutPoint&, const LayoutRect& damageRect, bool paintingOverlayControls = false);
     273    void paintScrollCorner(GraphicsContext*, const LayoutPoint&, const LayoutRect& damageRect);
     274    void paintResizer(GraphicsContext*, const LayoutPoint&, const LayoutRect& damageRect);
    275275
    276276    void updateScrollInfoAfterLayout();
  • trunk/Source/WebCore/rendering/RenderLineBoxList.cpp

    r88319 r90600  
    201201}
    202202
    203 void RenderLineBoxList::paint(RenderBoxModelObject* renderer, PaintInfo& paintInfo, const IntPoint& paintOffset) const
     203void RenderLineBoxList::paint(RenderBoxModelObject* renderer, PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
    204204{
    205205    // Only paint during the foreground/selection phases.
     
    219219    RenderView* v = renderer->view();
    220220    bool usePrintRect = !v->printRect().isEmpty();
    221     int outlineSize = renderer->maximalOutlineSize(paintInfo.phase);
     221    LayoutUnit outlineSize = renderer->maximalOutlineSize(paintInfo.phase);
    222222    if (!anyLineIntersectsRect(renderer, paintInfo.rect, paintOffset, usePrintRect, outlineSize))
    223223        return;
     
    236236            // text pages, so we don't have to deal with vertical lines at all here.
    237237            RootInlineBox* root = curr->root();
    238             int topForPaginationCheck = curr->logicalTopVisualOverflow(root->lineTop());
    239             int bottomForPaginationCheck = curr->logicalLeftVisualOverflow();
     238            LayoutUnit topForPaginationCheck = curr->logicalTopVisualOverflow(root->lineTop());
     239            LayoutUnit bottomForPaginationCheck = curr->logicalLeftVisualOverflow();
    240240            if (!curr->parent()) {
    241241                // We're a root box.  Use lineTop and lineBottom as well here.
  • trunk/Source/WebCore/rendering/RenderListBox.cpp

    r90590 r90600  
    331331}
    332332
    333 void RenderListBox::paintScrollbar(PaintInfo& paintInfo, const IntPoint& paintOffset)
     333void RenderListBox::paintScrollbar(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    334334{
    335335    if (m_vBar) {
    336         IntRect scrollRect(paintOffset.x() + width() - borderRight() - m_vBar->width(),
    337                            paintOffset.y() + borderTop(),
    338                            m_vBar->width(),
    339                            height() - (borderTop() + borderBottom()));
     336        LayoutRect scrollRect(paintOffset.x() + width() - borderRight() - m_vBar->width(),
     337            paintOffset.y() + borderTop(),
     338            m_vBar->width(),
     339            height() - (borderTop() + borderBottom()));
    340340        m_vBar->setFrameRect(scrollRect);
    341341        m_vBar->paint(paintInfo.context, paintInfo.rect);
     
    362362}
    363363
    364 void RenderListBox::paintItemForeground(PaintInfo& paintInfo, const IntPoint& paintOffset, int listIndex)
     364void RenderListBox::paintItemForeground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
    365365{
    366366    FontCachePurgePreventer fontCachePurgePreventer;
     
    400400    TextRun textRun(string, length, false, 0, 0, TextRun::AllowTrailingExpansion, itemStyle->direction(), itemStyle->unicodeBidi() == Override, TextRun::NoRounding);
    401401    Font itemFont = style()->font();
    402     IntRect r = itemBoundingBoxRect(paintOffset, listIndex);
     402    LayoutRect r = itemBoundingBoxRect(paintOffset, listIndex);
    403403    r.move(itemOffsetForAlignment(textRun, itemStyle, itemFont, r));
    404404
     
    415415}
    416416
    417 void RenderListBox::paintItemBackground(PaintInfo& paintInfo, const IntPoint& paintOffset, int listIndex)
     417void RenderListBox::paintItemBackground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
    418418{
    419419    SelectElement* select = toSelectElement(static_cast<Element*>(node()));
     
    434434    if (!element->renderStyle() || element->renderStyle()->visibility() != HIDDEN) {
    435435        ColorSpace colorSpace = element->renderStyle() ? element->renderStyle()->colorSpace() : style()->colorSpace();
    436         IntRect itemRect = itemBoundingBoxRect(paintOffset, listIndex);
     436        LayoutRect itemRect = itemBoundingBoxRect(paintOffset, listIndex);
    437437        itemRect.intersect(controlClipRect(paintOffset));
    438438        paintInfo.context->fillRect(itemRect, backColor, colorSpace);
  • trunk/Source/WebCore/rendering/RenderListBox.h

    r90590 r90600  
    136136    int numItems() const;
    137137    int listHeight() const;
    138     void paintScrollbar(PaintInfo&, const IntPoint&);
    139     void paintItemForeground(PaintInfo&, const IntPoint&, int listIndex);
    140     void paintItemBackground(PaintInfo&, const IntPoint&, int listIndex);
     138    void paintScrollbar(PaintInfo&, const LayoutPoint&);
     139    void paintItemForeground(PaintInfo&, const LayoutPoint&, int listIndex);
     140    void paintItemBackground(PaintInfo&, const LayoutPoint&, int listIndex);
    141141    void scrollToRevealSelection();
    142142
  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r90530 r90600  
    10061006#endif
    10071007   
    1008 void RenderObject::paintFocusRing(GraphicsContext* context, const IntPoint& paintOffset, RenderStyle* style)
    1009 {
    1010     Vector<IntRect> focusRingRects;
     1008void RenderObject::paintFocusRing(GraphicsContext* context, const LayoutPoint& paintOffset, RenderStyle* style)
     1009{
     1010    Vector<LayoutRect> focusRingRects;
    10111011    addFocusRingRects(focusRingRects, paintOffset);
    10121012    if (style->outlineStyleIsAuto())
     
    10291029}
    10301030
    1031 void RenderObject::paintOutline(GraphicsContext* graphicsContext, const IntRect& paintRect)
     1031void RenderObject::paintOutline(GraphicsContext* graphicsContext, const LayoutRect& paintRect)
    10321032{
    10331033    if (!hasOutline())
     
    10351035
    10361036    RenderStyle* styleToUse = style();
    1037     int outlineWidth = styleToUse->outlineWidth();
     1037    LayoutUnit outlineWidth = styleToUse->outlineWidth();
    10381038    EBorderStyle outlineStyle = styleToUse->outlineStyle();
    10391039
    10401040    Color outlineColor = styleToUse->visitedDependentColor(CSSPropertyOutlineColor);
    10411041
    1042     int offset = styleToUse->outlineOffset();
     1042    LayoutUnit offset = styleToUse->outlineOffset();
    10431043
    10441044    if (styleToUse->outlineStyleIsAuto() || hasOutlineAnnotation()) {
     
    10521052        return;
    10531053
    1054     IntRect adjustedPaintRec = paintRect;
     1054    LayoutRect adjustedPaintRec = paintRect;
    10551055    adjustedPaintRec.inflate(offset);
    10561056
     
    10681068#endif
    10691069
    1070     int leftOuter = adjustedPaintRec.x() - outlineWidth;
    1071     int leftInner = adjustedPaintRec.x();
    1072     int rightOuter = adjustedPaintRec.maxX() + outlineWidth;
    1073     int rightInner = adjustedPaintRec.maxX();
    1074     int topOuter = adjustedPaintRec.y() - outlineWidth;
    1075     int topInner = adjustedPaintRec.y();
    1076     int bottomOuter = adjustedPaintRec.maxY() + outlineWidth;
    1077     int bottomInner = adjustedPaintRec.maxY();
     1070    LayoutUnit leftOuter = adjustedPaintRec.x() - outlineWidth;
     1071    LayoutUnit leftInner = adjustedPaintRec.x();
     1072    LayoutUnit rightOuter = adjustedPaintRec.maxX() + outlineWidth;
     1073    LayoutUnit rightInner = adjustedPaintRec.maxX();
     1074    LayoutUnit topOuter = adjustedPaintRec.y() - outlineWidth;
     1075    LayoutUnit topInner = adjustedPaintRec.y();
     1076    LayoutUnit bottomOuter = adjustedPaintRec.maxY() + outlineWidth;
     1077    LayoutUnit bottomInner = adjustedPaintRec.maxY();
    10781078   
    10791079    drawLineForBoxSide(graphicsContext, leftOuter, topOuter, leftInner, bottomOuter, BSLeft, outlineColor, outlineStyle, outlineWidth, outlineWidth);
  • trunk/Source/WebCore/rendering/RenderObject.h

    r90596 r90600  
    794794                            Color, EBorderStyle, int adjbw1, int adjbw2, bool antialias = false);
    795795
    796     void paintFocusRing(GraphicsContext*, const IntPoint&, RenderStyle*);
    797     void paintOutline(GraphicsContext*, const IntRect&);
     796    void paintFocusRing(GraphicsContext*, const LayoutPoint&, RenderStyle*);
     797    void paintOutline(GraphicsContext*, const LayoutRect&);
    798798    void addPDFURLRect(GraphicsContext*, const IntRect&);
    799799
  • trunk/Source/WebCore/rendering/RenderReplaced.cpp

    r90596 r90600  
    164164}
    165165
    166 bool RenderReplaced::shouldPaint(PaintInfo& paintInfo, const IntPoint& paintOffset)
     166bool RenderReplaced::shouldPaint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    167167{
    168168    if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline
     
    177177        return false;
    178178
    179     IntPoint adjustedPaintOffset = paintOffset + location();
     179    LayoutPoint adjustedPaintOffset = paintOffset + location();
    180180
    181181    // Early exit if the element touches the edges.
    182     int top = adjustedPaintOffset.y() + minYVisualOverflow();
    183     int bottom = adjustedPaintOffset.y() + maxYVisualOverflow();
     182    LayoutUnit top = adjustedPaintOffset.y() + minYVisualOverflow();
     183    LayoutUnit bottom = adjustedPaintOffset.y() + maxYVisualOverflow();
    184184    if (isSelected() && m_inlineBoxWrapper) {
    185         int selTop = paintOffset.y() + m_inlineBoxWrapper->root()->selectionTop();
    186         int selBottom = paintOffset.y() + selTop + m_inlineBoxWrapper->root()->selectionHeight();
     185        LayoutUnit selTop = paintOffset.y() + m_inlineBoxWrapper->root()->selectionTop();
     186        LayoutUnit selBottom = paintOffset.y() + selTop + m_inlineBoxWrapper->root()->selectionHeight();
    187187        top = min(selTop, top);
    188188        bottom = max(selBottom, bottom);
    189189    }
    190190   
    191     int os = 2 * maximalOutlineSize(paintInfo.phase);
     191    LayoutUnit os = 2 * maximalOutlineSize(paintInfo.phase);
    192192    if (adjustedPaintOffset.x() + minXVisualOverflow() >= paintInfo.rect.maxX() + os || adjustedPaintOffset.x() + maxXVisualOverflow() <= paintInfo.rect.x() - os)
    193193        return false;
  • trunk/Source/WebCore/rendering/RenderReplaced.h

    r90596 r90600  
    5656
    5757    virtual void paint(PaintInfo&, const LayoutPoint&);
    58     bool shouldPaint(PaintInfo&, const IntPoint&);
     58    bool shouldPaint(PaintInfo&, const LayoutPoint&);
    5959    IntRect localSelectionRect(bool checkWhetherSelected = true) const; // This is in local coordinates, but it's a physical rect (so the top left corner is physical top left).
    6060
  • trunk/Source/WebCore/rendering/RenderScrollbarPart.cpp

    r90302 r90600  
    160160}
    161161
    162 void RenderScrollbarPart::paintIntoRect(GraphicsContext* graphicsContext, const IntPoint& paintOffset, const IntRect& rect)
     162void RenderScrollbarPart::paintIntoRect(GraphicsContext* graphicsContext, const LayoutPoint& paintOffset, const LayoutRect& rect)
    163163{
    164164    // Make sure our dimensions match the rect.
  • trunk/Source/WebCore/rendering/RenderScrollbarPart.h

    r88250 r90600  
    4646    virtual void computePreferredLogicalWidths();
    4747   
    48     void paintIntoRect(GraphicsContext*, const IntPoint&, const IntRect&);
     48    void paintIntoRect(GraphicsContext*, const LayoutPoint&, const LayoutRect&);
    4949   
    5050protected:
  • trunk/Source/WebCore/rendering/RenderTableCell.cpp

    r90525 r90600  
    961961}
    962962
    963 void RenderTableCell::paintBackgroundsBehindCell(PaintInfo& paintInfo, const IntPoint& paintOffset, RenderObject* backgroundObject)
     963void RenderTableCell::paintBackgroundsBehindCell(PaintInfo& paintInfo, const LayoutPoint& paintOffset, RenderObject* backgroundObject)
    964964{
    965965    if (!paintInfo.shouldPaintWithinRoot(this))
     
    976976        return;
    977977
    978     IntPoint adjustedPaintOffset = paintOffset;
     978    LayoutPoint adjustedPaintOffset = paintOffset;
    979979    if (backgroundObject != this)
    980980        adjustedPaintOffset.move(location());
     
    989989        GraphicsContextStateSaver stateSaver(*paintInfo.context, shouldClip);
    990990        if (shouldClip) {
    991             IntRect clipRect(adjustedPaintOffset.x() + borderLeft(), adjustedPaintOffset.y() + borderTop(),
     991            LayoutRect clipRect(adjustedPaintOffset.x() + borderLeft(), adjustedPaintOffset.y() + borderTop(),
    992992                width() - borderLeft() - borderRight(), height() - borderTop() - borderBottom());
    993993            paintInfo.context->clip(clipRect);
    994994        }
    995         paintFillLayers(paintInfo, c, bgLayer, IntRect(adjustedPaintOffset, size()), BackgroundBleedNone, CompositeSourceOver, backgroundObject);
     995        paintFillLayers(paintInfo, c, bgLayer, LayoutRect(adjustedPaintOffset, size()), BackgroundBleedNone, CompositeSourceOver, backgroundObject);
    996996    }
    997997}
  • trunk/Source/WebCore/rendering/RenderTableSection.cpp

    r90515 r90600  
    914914}
    915915
    916 void RenderTableSection::paintCell(RenderTableCell* cell, PaintInfo& paintInfo, const IntPoint& paintOffset)
    917 {
    918     IntPoint cellPoint = flipForWritingMode(cell, paintOffset, ParentToChildFlippingAdjustment);
     916void RenderTableSection::paintCell(RenderTableCell* cell, PaintInfo& paintInfo, const LayoutPoint& paintOffset)
     917{
     918    LayoutPoint cellPoint = flipForWritingMode(cell, paintOffset, ParentToChildFlippingAdjustment);
    919919    PaintPhase paintPhase = paintInfo.phase;
    920920    RenderTableRow* row = toRenderTableRow(cell->parent());
  • trunk/Source/WebCore/rendering/RenderTableSection.h

    r90515 r90600  
    134134
    135135    virtual void paint(PaintInfo&, const LayoutPoint&);
    136     virtual void paintCell(RenderTableCell*, PaintInfo&, const IntPoint&);
     136    virtual void paintCell(RenderTableCell*, PaintInfo&, const LayoutPoint&);
    137137    virtual void paintObject(PaintInfo&, const LayoutPoint&);
    138138
  • trunk/Source/WebCore/rendering/RenderTextControl.cpp

    r90591 r90600  
    588588}
    589589
    590 void RenderTextControl::paintPlaceholder(PaintInfo& paintInfo, const IntPoint& paintOffset)
     590void RenderTextControl::paintPlaceholder(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
    591591{
    592592    if (style()->visibility() != VISIBLE)
    593593        return;
    594594   
    595     IntRect clipRect(paintOffset.x() + borderLeft(), paintOffset.y() + borderTop(), width() - borderLeft() - borderRight(), height() - borderBottom() - borderTop());
     595    LayoutRect clipRect(paintOffset.x() + borderLeft(), paintOffset.y() + borderTop(), width() - borderLeft() - borderRight(), height() - borderBottom() - borderTop());
    596596    if (clipRect.isEmpty())
    597597        return;
     
    611611    RenderBox* textRenderer = innerTextElement() ? innerTextElement()->renderBox() : 0;
    612612    if (textRenderer) {
    613         IntPoint textPoint;
     613        LayoutPoint textPoint;
    614614        textPoint.setY(paintOffset.y() + textBlockInsetTop() + placeholderStyle->fontMetrics().ascent());
    615         int styleTextIndent = placeholderStyle->textIndent().isFixed() ? placeholderStyle->textIndent().calcMinValue(0) : 0;
     615        LayoutUnit styleTextIndent = placeholderStyle->textIndent().isFixed() ? placeholderStyle->textIndent().calcMinValue(0) : 0;
    616616        if (placeholderStyle->isLeftToRightDirection())
    617617            textPoint.setX(paintOffset.x() + styleTextIndent + textBlockInsetLeft());
  • trunk/Source/WebCore/rendering/RootInlineBox.cpp

    r90596 r90600  
    134134}
    135135
    136 void RootInlineBox::paintEllipsisBox(PaintInfo& paintInfo, const IntPoint& paintOffset, int lineTop, int lineBottom) const
     136void RootInlineBox::paintEllipsisBox(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom) const
    137137{
    138138    if (hasEllipsisBox() && paintInfo.shouldPaintWithinRoot(renderer()) && renderer()->style()->visibility() == VISIBLE
     
    158158}
    159159
    160 void RootInlineBox::paintCustomHighlight(PaintInfo& paintInfo, const IntPoint& paintOffset, const AtomicString& highlightType)
     160void RootInlineBox::paintCustomHighlight(PaintInfo& paintInfo, const LayoutPoint& paintOffset, const AtomicString& highlightType)
    161161{
    162162    if (!paintInfo.shouldPaintWithinRoot(renderer()) || renderer()->style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseForeground)
     
    179179#endif
    180180
    181 void RootInlineBox::paint(PaintInfo& paintInfo, const IntPoint& paintOffset, int lineTop, int lineBottom)
     181void RootInlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
    182182{
    183183    InlineFlowBox::paint(paintInfo, paintOffset, lineTop, lineBottom);
  • trunk/Source/WebCore/rendering/RootInlineBox.h

    r90596 r90600  
    8686    EllipsisBox* ellipsisBox() const;
    8787
    88     void paintEllipsisBox(PaintInfo&, const IntPoint&, int lineTop, int lineBottom) const;
     88    void paintEllipsisBox(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom) const;
    8989
    9090    virtual void clearTruncation();
     
    9595#if PLATFORM(MAC)
    9696    void addHighlightOverflow();
    97     void paintCustomHighlight(PaintInfo&, const IntPoint&, const AtomicString& highlightType);
     97    void paintCustomHighlight(PaintInfo&, const LayoutPoint&, const AtomicString& highlightType);
    9898#endif
    9999
    100     virtual void paint(PaintInfo&, const IntPoint&, int lineTop, int lineBottom);
     100    virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
    101101    virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const LayoutPoint& pointInContainer, const LayoutPoint& accumulatedOffset, int lineTop, int lineBottom);
    102102
  • trunk/Source/WebCore/rendering/mathml/RenderMathMLBlock.cpp

    r88250 r90600  
    7676
    7777#if ENABLE(DEBUG_MATH_LAYOUT)
    78 void RenderMathMLBlock::paint(PaintInfo& info, const IntPoint& paintOffset)
     78void RenderMathMLBlock::paint(PaintInfo& info, const LayoutPoint& paintOffset)
    7979{
    8080    RenderBlock::paint(info, paintOffset);
     
    8383        return;
    8484
    85     IntPoint adjustedPaintOffset = paintOffset + location();
     85    LayoutPoint adjustedPaintOffset = paintOffset + location();
    8686
    8787    GraphicsContextStateSaver stateSaver(*info.context);
     
    9191    info.context->setStrokeColor(Color(0, 0, 255), ColorSpaceSRGB);
    9292   
    93     info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y()));
    94     info.context->drawLine(IntPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y()), IntPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + offsetHeight()));
    95     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + offsetHeight()), IntPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + offsetHeight()));
    96     info.context->drawLine(adjustedPaintOffset, IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + offsetHeight()));
     93    info.context->drawLine(adjustedPaintOffset, LayoutPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y()));
     94    info.context->drawLine(LayoutPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y()), LayoutPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + offsetHeight()));
     95    info.context->drawLine(LayoutPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + offsetHeight()), LayoutPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + offsetHeight()));
     96    info.context->drawLine(adjustedPaintOffset, LayoutPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + offsetHeight()));
    9797   
    9898    int topStart = paddingTop();
     
    100100    info.context->setStrokeColor(Color(0, 255, 0), ColorSpaceSRGB);
    101101   
    102     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + topStart), IntPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + topStart));
     102    info.context->drawLine(LayoutPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + topStart), LayoutPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + topStart));
    103103   
    104104    int baseline = baselinePosition(AlphabeticBaseline, true, HorizontalLine);
     
    106106    info.context->setStrokeColor(Color(255, 0, 0), ColorSpaceSRGB);
    107107   
    108     info.context->drawLine(IntPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + baseline), IntPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + baseline));
     108    info.context->drawLine(LayoutPoint(adjustedPaintOffset.x(), adjustedPaintOffset.y() + baseline), LayoutPoint(adjustedPaintOffset.x() + offsetWidth(), adjustedPaintOffset.y() + baseline));
    109109}
    110110#endif // ENABLE(DEBUG_MATH_LAYOUT)
  • trunk/Source/WebCore/rendering/mathml/RenderMathMLFraction.cpp

    r88250 r90600  
    132132}
    133133
    134 void RenderMathMLFraction::paint(PaintInfo& info, const IntPoint& paintOffset)
     134void RenderMathMLFraction::paint(PaintInfo& info, const LayoutPoint& paintOffset)
    135135{
    136136    RenderMathMLBlock::paint(info, paintOffset);
     
    141141        return;
    142142
    143     int verticalOffset = 0;
     143    LayoutUnit verticalOffset = 0;
    144144    // The children are always RenderMathMLBlock instances
    145145    if (firstChild()->isRenderMathMLBlock()) {
     
    154154    }
    155155   
    156     IntPoint adjustedPaintOffset = paintOffset + location();
     156    LayoutPoint adjustedPaintOffset = paintOffset + location();
    157157    adjustedPaintOffset.setY(adjustedPaintOffset.y() + verticalOffset);
    158158   
  • trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp

    r90302 r90600  
    9595}
    9696   
    97 void RenderMathMLRoot::paint(PaintInfo& info, const IntPoint& paintOffset)
     97void RenderMathMLRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)
    9898{
    9999    RenderMathMLBlock::paint(info, paintOffset);
     
    105105        return;
    106106
    107     IntPoint adjustedPaintOffset = paintOffset + location();
     107    LayoutPoint adjustedPaintOffset = paintOffset + location();
    108108   
    109109    RenderBoxModelObject* indexBox = toRenderBoxModelObject(lastChild());
    110110   
    111     int maxHeight = indexBox->offsetHeight();
     111    LayoutUnit maxHeight = indexBox->offsetHeight();
    112112    // default to the font size in pixels if we're empty
    113113    if (!maxHeight)
    114114        maxHeight = style()->fontSize();
    115     int width = indexBox->offsetWidth();
    116    
    117     int indexWidth = 0;
     115    LayoutUnit width = indexBox->offsetWidth();
     116   
     117    LayoutUnit indexWidth = 0;
    118118    RenderObject* current = firstChild();
    119119    while (current != lastChild()) {
     
    140140   
    141141    int rootPad = static_cast<int>(gRootPadding * style()->fontSize());
    142     int start = adjustedPaintOffset.x() + indexWidth + gRadicalLeftMargin + style()->paddingLeft().value() - rootPad;
     142    LayoutUnit start = adjustedPaintOffset.x() + indexWidth + gRadicalLeftMargin + style()->paddingLeft().value() - rootPad;
    143143    adjustedPaintOffset.setY(adjustedPaintOffset.y() + style()->paddingTop().value() - rootPad);
    144144   
  • trunk/Source/WebCore/rendering/mathml/RenderMathMLSquareRoot.cpp

    r90302 r90600  
    6767}
    6868
    69 void RenderMathMLSquareRoot::paint(PaintInfo& info, const IntPoint& paintOffset)
     69void RenderMathMLSquareRoot::paint(PaintInfo& info, const LayoutPoint& paintOffset)
    7070{
    7171    RenderMathMLBlock::paint(info, paintOffset);
     
    7474        return;
    7575   
    76     IntPoint adjustedPaintOffset = paintOffset + location();
     76    LayoutPoint adjustedPaintOffset = paintOffset + location();
    7777
    78     int maxHeight = 0;
    79     int width = 0;
     78    LayoutUnit maxHeight = 0;
     79    LayoutUnit width = 0;
    8080    RenderObject* current = firstChild();
    8181    while (current) {
Note: See TracChangeset for help on using the changeset viewer.