WebKit merge 40722:40785 (part 1)

third_party/WebKit/WebCore/rendering/RenderInline.cpp

 /*
  * This file is part of the render object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
  *
  * 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
@@ skipping 21 matching lines @@
 #include "RenderArena.h"
 #include "RenderBlock.h"
 #include "RenderView.h"
 #include "VisiblePosition.h"
 
 using namespace std;
 
 namespace WebCore {
 
 RenderInline::RenderInline(Node* node)
-    : RenderBox(node)
+    : RenderBoxModelObject(node)
     , m_continuation(0)
     , m_lineHeight(-1)
 {
     setChildrenInline(true);
 }
 
 RenderInline::~RenderInline()
 {
 }
 
 void RenderInline::destroy()
 {
     // Detach our continuation first.
     if (m_continuation)
         m_continuation->destroy();
     m_continuation = 0;
     
     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
     // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.
     children()->destroyLeftoverChildren();
 
     if (!documentBeingDestroyed()) {
         if (firstLineBox()) {
-            // We can't wait for RenderBox::destroy to clear the selection,
+            // We can't wait for RenderBoxModelObject::destroy to clear the selection,
             // because by then we will have nuked the line boxes.
             // FIXME: The SelectionController should be responsible for this when it
             // is notified of DOM mutations.
             if (isSelectionBorder())
                 view()->clearSelection();
 
             // If line boxes are contained inside a root, that means we're an inline.
             // In that case, we need to remove all the line boxes so that the parent
             // lines aren't pointing to deleted children. If the first line box does
             // not have a parent that means they are either already disconnected or
             // root lines that can just be destroyed without disconnecting.
             if (firstLineBox()->parent()) {
                 for (InlineRunBox* box = firstLineBox(); box; box = box->nextLineBox())
                     box->remove();
             }
         } else if (isInline() && parent())
             parent()->dirtyLinesFromChangedChild(this);
     }
 
     m_lineBoxes.deleteLineBoxes(renderArena());
 
-    RenderBox::destroy();
+    RenderBoxModelObject::destroy();
 }
 
 RenderInline* RenderInline::inlineContinuation() const
 {
     if (!m_continuation || m_continuation->isInline())
         return toRenderInline(m_continuation);
     return toRenderBlock(m_continuation)->inlineContinuation();
 }
 
 void RenderInline::updateBoxModelInfoFromStyle()
 {
     RenderBoxModelObject::updateBoxModelInfoFromStyle();
 
     setInline(true); // Needed for run-ins, since run-in is considered a block display type.
 
     // FIXME: Support transforms and reflections on inline flows someday.
     setHasTransform(false);
     setHasReflection(false);    
 }
 
 void RenderInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
-    RenderBox::styleDidChange(diff, oldStyle);
+    RenderBoxModelObject::styleDidChange(diff, oldStyle);
 
     // Ensure that all of the split inlines pick up the new style. We
     // only do this if we're an inline, since we don't want to propagate
     // a block's style to the other inlines.
     // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
     // and after the block share the same style, but the block doesn't
     // need to pass its style on to anyone else.
     for (RenderInline* currCont = inlineContinuation(); currCont; currCont = currCont->inlineContinuation()) {
-        RenderBox* nextCont = currCont->continuation();
+        RenderBoxModelObject* nextCont = currCont->continuation();
         currCont->setContinuation(0);
         currCont->setStyle(style());
         currCont->setContinuation(nextCont);
     }
 
     m_lineHeight = -1;
 
     // Update pseudos for :before and :after now.
     if (!isAnonymous() && document()->usesBeforeAfterRules()) {
         children()->updateBeforeAfterContent(this, BEFORE);
@@ skipping 13 matching lines @@
     return true;
 }
 
 void RenderInline::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
     if (continuation())
         return addChildToContinuation(newChild, beforeChild);
     return addChildIgnoringContinuation(newChild, beforeChild);
 }
 
-static RenderBox* nextContinuation(RenderObject* renderer)
+static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
 {
     if (renderer->isInline() && !renderer->isReplaced())
         return toRenderInline(renderer)->continuation();
     return toRenderBlock(renderer)->inlineContinuation();
 }
 
-RenderBox* RenderInline::continuationBefore(RenderObject* beforeChild)
+RenderBoxModelObject* RenderInline::continuationBefore(RenderObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() == this)
         return this;
 
-    RenderBox* curr = nextContinuation(this);
-    RenderBox* nextToLast = this;
-    RenderBox* last = this;
+    RenderBoxModelObject* curr = nextContinuation(this);
+    RenderBoxModelObject* nextToLast = this;
+    RenderBoxModelObject* last = this;
     while (curr) {
         if (beforeChild && beforeChild->parent() == curr) {
             if (curr->firstChild() == beforeChild)
                 return last;
             return curr;
         }
 
         nextToLast = last;
         last = curr;
         curr = nextContinuation(curr);
@@ skipping 14 matching lines @@
         // We are placing a block inside an inline. We have to perform a split of this
         // inline into continuations.  This involves creating an anonymous block box to hold
         // |newChild|.  We then make that block box a continuation of this inline.  We take all of
         // the children after |beforeChild| and put them in a clone of this object.
         RefPtr<RenderStyle> newStyle = RenderStyle::create();
         newStyle->inheritFrom(style());
         newStyle->setDisplay(BLOCK);
 
         RenderBlock* newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);
         newBox->setStyle(newStyle.release());
-        RenderBox* oldContinuation = continuation();
+        RenderBoxModelObject* oldContinuation = continuation();
         setContinuation(newBox);
 
         // Someone may have put a <p> inside a <q>, causing a split.  When this happens, the :after content
         // has to move into the inline continuation.  Call updateBeforeAfterContent to ensure that our :after
         // content gets properly destroyed.
         bool isLastChild = (beforeChild == lastChild());
         if (document()->usesBeforeAfterRules())
             children()->updateBeforeAfterContent(this, AFTER);
         if (isLastChild && beforeChild != lastChild())
             beforeChild = 0; // We destroyed the last child, so now we need to update our insertion
                              // point to be 0.  It's just a straight append now.
 
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
     }
 
-    RenderBox::addChild(newChild, beforeChild);
+    RenderBoxModelObject::addChild(newChild, beforeChild);
 
     newChild->setNeedsLayoutAndPrefWidthsRecalc();
 }
 
 RenderInline* RenderInline::cloneInline(RenderInline* src)
 {
     RenderInline* o = new (src->renderArena()) RenderInline(src->element());
     o->setStyle(src->style());
     return o;
 }
 
 void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
                                 RenderBlock* middleBlock,
-                                RenderObject* beforeChild, RenderBox* oldCont)
+                                RenderObject* beforeChild, RenderBoxModelObject* oldCont)
 {
     // Create a clone of this inline.
     RenderInline* clone = cloneInline(this);
     clone->setContinuation(oldCont);
 
     // Now take all of the children from beforeChild to the end and remove
     // them from |this| and place them in the clone.
     RenderObject* o = beforeChild;
     while (o) {
         RenderObject* tmp = o;
         o = tmp->nextSibling();
         clone->addChildIgnoringContinuation(children()->removeChildNode(this, tmp), 0);
         tmp->setNeedsLayoutAndPrefWidthsRecalc();
     }
 
     // Hook |clone| up as the continuation of the middle block.
     middleBlock->setInlineContinuation(clone);
 
     // We have been reparented and are now under the fromBlock.  We need
     // to walk up our inline parent chain until we hit the containing block.
     // Once we hit the containing block we're done.
-    RenderBox* curr = static_cast<RenderBox*>(parent());
-    RenderBox* currChild = this;
+    RenderBoxModelObject* curr = static_cast<RenderBoxModelObject*>(parent());
+    RenderBoxModelObject* currChild = this;
     
     // FIXME: Because splitting is O(n^2) as tags nest pathologically, we cap the depth at which we're willing to clone.
     // There will eventually be a better approach to this problem that will let us nest to a much
     // greater depth (see bugzilla bug 13430) but for now we have a limit.  This *will* result in
     // incorrect rendering, but the alternative is to hang forever.
     unsigned splitDepth = 1;
     const unsigned cMaxSplitDepth = 200; 
     while (curr && curr != fromBlock) {
         ASSERT(curr->isRenderInline());
         if (splitDepth < cMaxSplitDepth) {
@@ skipping 22 matching lines @@
             while (o) {
                 RenderObject* tmp = o;
                 o = tmp->nextSibling();
                 clone->addChildIgnoringContinuation(inlineCurr->children()->removeChildNode(curr, tmp), 0);
                 tmp->setNeedsLayoutAndPrefWidthsRecalc();
             }
         }
         
         // Keep walking up the chain.
         currChild = curr;
-        curr = static_cast<RenderBox*>(curr->parent());
+        curr = static_cast<RenderBoxModelObject*>(curr->parent());
         splitDepth++;
     }
 
     // Now we are at the block level. We need to put the clone into the toBlock.
     toBlock->children()->appendChildNode(toBlock, clone);
 
     // Now take all the children after currChild and remove them from the fromBlock
     // and put them in the toBlock.
     o = currChild->nextSibling();
     while (o) {
         RenderObject* tmp = o;
         o = tmp->nextSibling();
         toBlock->children()->appendChildNode(toBlock, fromBlock->children()->removeChildNode(fromBlock, tmp));
     }
 }
 
 void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
-                             RenderObject* newChild, RenderBox* oldCont)
+                             RenderObject* newChild, RenderBoxModelObject* oldCont)
 {
     RenderBlock* pre = 0;
     RenderBlock* block = containingBlock();
     
     // Delete our line boxes before we do the inline split into continuations.
     block->deleteLineBoxTree();
     
     bool madeNewBeforeBlock = false;
     if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
         // We can reuse this block and make it the preBlock of the next continuation.
@@ skipping 38 matching lines @@
     // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
     // get deleted properly.  Because objects moves from the pre block into the post block, we want to
     // make new line boxes instead of leaving the old line boxes around.
     pre->setNeedsLayoutAndPrefWidthsRecalc();
     block->setNeedsLayoutAndPrefWidthsRecalc();
     post->setNeedsLayoutAndPrefWidthsRecalc();
 }
 
 void RenderInline::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
 {
-    RenderBox* flow = continuationBefore(beforeChild);
+    RenderBoxModelObject* flow = continuationBefore(beforeChild);
     ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
-    RenderBox* beforeChildParent = 0;
+    RenderBoxModelObject* beforeChildParent = 0;
     if (beforeChild)
-        beforeChildParent = static_cast<RenderBox*>(beforeChild->parent());
+        beforeChildParent = static_cast<RenderBoxModelObject*>(beforeChild->parent());
     else {
-        RenderBox* cont = nextContinuation(flow);
+        RenderBoxModelObject* cont = nextContinuation(flow);
         if (cont)
             beforeChildParent = cont;
         else
             beforeChildParent = flow;
     }
 
     if (newChild->isFloatingOrPositioned())
         return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
 
     // A continuation always consists of two potential candidates: an inline or an anonymous
@@ skipping 23 matching lines @@
 
 void RenderInline::absoluteRects(Vector<IntRect>& rects, int tx, int ty, bool topLevel)
 {
     for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
         rects.append(IntRect(tx + curr->xPos(), ty + curr->yPos(), curr->width(), curr->height()));
 
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isBox()) {
             RenderBox* box = toRenderBox(curr);
             curr->absoluteRects(rects, tx + box->x(), ty + box->y(), false);
-        }
+        } else
+            curr->absoluteRects(rects, tx, ty, false);
     }
 
-    if (continuation() && topLevel)
-        continuation()->absoluteRects(rects, 
-                                      tx - containingBlock()->x() + continuation()->x(),
-                                      ty - containingBlock()->y() + continuation()->y(),
-                                      topLevel);
+    if (continuation() && topLevel) {
+        if (continuation()->isBox()) {
+            RenderBox* box = toRenderBox(continuation());
+            continuation()->absoluteRects(rects, 
+                                          tx - containingBlock()->x() + box->x(),
+                                          ty - containingBlock()->y() + box->y(),
+                                          topLevel);
+        } else
+            continuation()->absoluteRects(rects, tx - containingBlock()->x(), ty - containingBlock()->y(), topLevel);
+    }
 }
 
 void RenderInline::absoluteQuads(Vector<FloatQuad>& quads, bool topLevel)
 {
     for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
         FloatRect localRect(curr->xPos(), curr->yPos(), curr->width(), curr->height());
         quads.append(localToAbsoluteQuad(localRect));
     }
     
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
             curr->absoluteQuads(quads, false);
     }
 
     if (continuation() && topLevel)
         continuation()->absoluteQuads(quads, topLevel);
 }
 
 int RenderInline::offsetLeft() const
 {
-    int x = RenderBox::offsetLeft();
+    int x = RenderBoxModelObject::offsetLeft();
     if (firstLineBox())
         x += firstLineBox()->xPos();
     return x;
 }
 
 int RenderInline::offsetTop() const
 {
-    int y = RenderBox::offsetTop();
+    int y = RenderBoxModelObject::offsetTop();
     if (firstLineBox())
         y += firstLineBox()->yPos();
     return y;
 }
 
+int RenderInline::marginLeft() const
+{
+    Length margin = style()->marginLeft();
+    if (margin.isAuto())
+        return 0;
+    if (margin.isFixed())
+        return margin.value();
+    if (margin.isPercent())
+        return margin.calcMinValue(max(0, containingBlockWidth()));
+    return 0;
+}
+
+int RenderInline::marginRight() const
+{
+    Length margin = style()->marginRight();
+    if (margin.isAuto())
+        return 0;
+    if (margin.isFixed())
+        return margin.value();
+    if (margin.isPercent())
+        return margin.calcMinValue(max(0, containingBlockWidth()));
+    return 0;
+}
+
 const char* RenderInline::renderName() const
 {
     if (isRelPositioned())
         return "RenderInline (relative positioned)";
     if (isAnonymous())
         return "RenderInline (generated)";
     if (isRunIn())
         return "RenderInline (run-in)";
     return "RenderInline";
 }
 
 bool RenderInline::nodeAtPoint(const HitTestRequest& request, HitTestResult& result,
                                 int x, int y, int tx, int ty, HitTestAction hitTestAction)
 {
     return m_lineBoxes.hitTest(this, request, result, x, y, tx, ty, hitTestAction);
 }
 
 VisiblePosition RenderInline::positionForCoordinates(int x, int y)
 {
+    // FIXME: Does not deal with relative positioned inlines (should it?)
+    RenderBlock* cb = containingBlock();
+    if (firstLineBox()) {
+        // This inline actually has a line box.  We must have clicked in the border/padding of one of these boxes.  We
+        // should try to find a result by asking our containing block.
+        return cb->positionForCoordinates(x, y);
+    }
+
     // Translate the coords from the pre-anonymous block to the post-anonymous block.
-    RenderBlock* cb = containingBlock();
     int parentBlockX = cb->x() + x;
     int parentBlockY = cb->y() + y;
-    RenderBox* c = continuation();
+    RenderBoxModelObject* c = continuation();
     while (c) {
-        RenderBox* contBlock = c;
+        RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
         if (c->isInline() || c->firstChild())
             return c->positionForCoordinates(parentBlockX - contBlock->x(), parentBlockY - contBlock->y());
         c = toRenderBlock(c)->inlineContinuation();
     }
     
-    return RenderBox::positionForCoordinates(x, y);
+    return RenderBoxModelObject::positionForCoordinates(x, y);
 }
 
 IntRect RenderInline::linesBoundingBox() const
 {
     IntRect result;
     
     // See <rdar://problem/5289721>, for an unknown reason the linked list here is sometimes inconsistent, first is non-zero and last is zero.  We have been
     // unable to reproduce this at all (and consequently unable to figure ot why this is happening).  The assert will hopefully catch the problem in debug
     // builds and help us someday figure out why.  We also put in a redundant check of lastLineBox() to avoid the crash for now.
     ASSERT(!firstLineBox() == !lastLineBox());  // Either both are null or both exist.
@@ skipping 31 matching lines @@
 
     // Now invalidate a rectangle.
     int ow = style() ? style()->outlineSize() : 0;
     
     // We need to add in the relative position offsets of any inlines (including us) up to our
     // containing block.
     RenderBlock* cb = containingBlock();
     for (RenderObject* inlineFlow = this; inlineFlow && inlineFlow->isRenderInline() && inlineFlow != cb; 
          inlineFlow = inlineFlow->parent()) {
          if (inlineFlow->style()->position() == RelativePosition && inlineFlow->hasLayer())
-            toRenderBox(inlineFlow)->layer()->relativePositionOffset(left, top);
+            toRenderInline(inlineFlow)->layer()->relativePositionOffset(left, top);
     }
 
     IntRect r(-ow + left, -ow + top, boundingBox.width() + ow * 2, boundingBox.height() + ow * 2);
     if (cb->hasColumns())
         cb->adjustRectForColumns(r);
 
     if (cb->hasOverflowClip()) {
         // cb->height() is inaccurate if we're in the middle of a layout of |cb|, so use the
         // layer's size instead.  Even if the layer's size is wrong, the layer itself will repaint
         // anyway if its size does change.
@@ skipping 22 matching lines @@
             IntRect contRect = continuation()->rectWithOutlineForRepaint(repaintContainer, ow);
             r.unite(contRect);
         }
     }
 
     return r;
 }
 
 IntRect RenderInline::rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth)
 {
-    IntRect r(RenderBox::rectWithOutlineForRepaint(repaintContainer, outlineWidth));
+    IntRect r(RenderBoxModelObject::rectWithOutlineForRepaint(repaintContainer, outlineWidth));
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
             r.unite(curr->rectWithOutlineForRepaint(repaintContainer, outlineWidth));
     }
     return r;
 }
 
+void RenderInline::computeRectForRepaint(RenderBoxModelObject* repaintContainer, IntRect& rect, bool fixed)
+{
+    if (RenderView* v = view()) {
+        // LayoutState is only valid for root-relative repainting
+        if (v->layoutStateEnabled() && !repaintContainer) {
+            LayoutState* layoutState = v->layoutState();
+            if (style()->position() == RelativePosition && layer())
+                rect.move(layer()->relativePositionOffset());
+            rect.move(layoutState->m_offset);
+            if (layoutState->m_clipped)
+                rect.intersect(layoutState->m_clipRect);
+            return;
+        }
+    }
+
+    if (repaintContainer == this)
+        return;
+
+    RenderObject* o = container();
+    if (!o)
+        return;
+
+    IntPoint topLeft = rect.location();
+
+    if (o->isBlockFlow() && style()->position() != AbsolutePosition && style()->position() != FixedPosition) {
+        RenderBlock* cb = toRenderBlock(o);
+        if (cb->hasColumns()) {
+            IntRect repaintRect(topLeft, rect.size());
+            cb->adjustRectForColumns(repaintRect);
+            topLeft = repaintRect.location();
+            rect = repaintRect;
+        }
+    }
+
+    if (style()->position() == RelativePosition && layer()) {
+        // Apply the relative position offset when invalidating a rectangle.  The layer
+        // is translated, but the render box isn't, so we need to do this to get the
+        // right dirty rect.  Since this is called from RenderObject::setStyle, the relative position
+        // flag on the RenderObject has been cleared, so use the one on the style().
+        topLeft += layer()->relativePositionOffset();
+    }
+    
+    // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
+    // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
+    if (o->hasOverflowClip()) {
+        RenderBox* containerBox = toRenderBox(o);
+
+        // o->height() is inaccurate if we're in the middle of a layout of |o|, so use the
+        // layer's size instead.  Even if the layer's size is wrong, the layer itself will repaint
+        // anyway if its size does change.
+        topLeft -= containerBox->layer()->scrolledContentOffset(); // For overflow:auto/scroll/hidden.
+
+        IntRect repaintRect(topLeft, rect.size());
+        IntRect boxRect(0, 0, containerBox->layer()->width(), containerBox->layer()->height());
+        rect = intersection(repaintRect, boxRect);
+        if (rect.isEmpty())
+            return;
+    } else
+        rect.setLocation(topLeft);
+    
+    o->computeRectForRepaint(repaintContainer, rect, fixed);
+}
+
 void RenderInline::updateDragState(bool dragOn)
 {
-    RenderBox::updateDragState(dragOn);
+    RenderBoxModelObject::updateDragState(dragOn);
     if (continuation())
         continuation()->updateDragState(dragOn);
 }
 
 void RenderInline::childBecameNonInline(RenderObject* child)
 {
     // We have to split the parent flow.
     RenderBlock* newBox = createAnonymousBlock();
-    RenderBox* oldContinuation = continuation();
+    RenderBoxModelObject* oldContinuation = continuation();
     setContinuation(newBox);
     RenderObject* beforeChild = child->nextSibling();
     children()->removeChildNode(this, child);
     splitFlow(beforeChild, newBox, child, oldContinuation);
 }
 
 void RenderInline::updateHitTestResult(HitTestResult& result, const IntPoint& point)
 {
     if (result.innerNode())
         return;
 
     Node* node = element();
     IntPoint localPoint(point);
     if (node) {
         if (isInlineContinuation()) {
             // We're in the continuation of a split inline.  Adjust our local point to be in the coordinate space
             // of the principal renderer's containing block.  This will end up being the innerNonSharedNode.
             RenderBlock* firstBlock = node->renderer()->containingBlock();
             
             // Get our containing block.
-            RenderBox* block = this;
-            if (isInline())
-                block = containingBlock();
-        
+            RenderBox* block = containingBlock();
             localPoint.move(block->x() - firstBlock->x(), block->y() - firstBlock->y());
         }
 
         result.setInnerNode(node);
         if (!result.innerNonSharedNode())
             result.setInnerNonSharedNode(node);
         result.setLocalPoint(localPoint);
     }
 }
 
@@ skipping 56 matching lines @@
     else if (!child->style()->isOriginalDisplayInlineType())
         // Avoid adding in the left border/padding of the containing block twice.  Subtract it out.
         offset.setWidth(sx - (child->containingBlock()->borderLeft() + child->containingBlock()->paddingLeft()));
 
     if (!child->style()->hasStaticY())
         offset.setHeight(sy);
 
     return offset;
 }
 
+void RenderInline::imageChanged(WrappedImagePtr, const IntRect*)
+{
+    if (!parent())
+        return;
+        
+    // FIXME: We can do better.
+    repaint();
+}
+
 void RenderInline::addFocusRingRects(GraphicsContext* graphicsContext, int tx, int ty)
 {
     for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
         graphicsContext->addFocusRingRect(IntRect(tx + curr->xPos(), ty + curr->yPos(), curr->width(), curr->height()));
 
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
-        if (!curr->isText() && !curr->isListMarker() && curr->isBox()) {
-            RenderBox* box = toRenderBox(curr);
-            FloatPoint pos;
+        if (!curr->isText() && !curr->isListMarker()) {
+            FloatPoint pos(tx, ty);
             // FIXME: This doesn't work correctly with transforms.
-            if (box->layer()) 
+            if (curr->hasLayer()) 
                 pos = curr->localToAbsolute();
-            else
-                pos = FloatPoint(tx + box->x(), ty + box->y());
-            box->addFocusRingRects(graphicsContext, pos.x(), pos.y());
+            else if (curr->isBox())
+                pos.move(toRenderBox(curr)->x(), toRenderBox(curr)->y());
+           curr->addFocusRingRects(graphicsContext, pos.x(), pos.y());
         }
     }
 
-    if (continuation())
-        continuation()->addFocusRingRects(graphicsContext, 
-                                          tx - containingBlock()->x() + continuation()->x(),
-                                          ty - containingBlock()->y() + continuation()->y());
+    if (continuation()) {
+        if (continuation()->isInline())
+            continuation()->addFocusRingRects(graphicsContext, 
+                                              tx - containingBlock()->x() + continuation()->containingBlock()->x(),
+                                              ty - containingBlock()->y() + continuation()->containingBlock()->y());
+        else
+            continuation()->addFocusRingRects(graphicsContext, 
+                                              tx - containingBlock()->x() + toRenderBox(continuation())->x(),
+                                              ty - containingBlock()->y() + toRenderBox(continuation())->y());
+    }
 }
 
 void RenderInline::paintOutline(GraphicsContext* graphicsContext, int tx, int ty)
 {
     if (!hasOutline())
         return;
     
     if (style()->outlineStyleIsAuto() || hasOutlineAnnotation()) {
         int ow = style()->outlineWidth();
         Color oc = style()->outlineColor();
@@ skipping 150 matching lines @@
                 region.clip.scale(pageScaleFactor);
             }
         }
 
         regions.append(region);
     }
 }
 #endif
 
 } // namespace WebCore