WebCore/rendering/RenderInline.cpp - WebKit - Git at Google

 /*
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  *
  */

 #include "config.h"
 #include "RenderInline.h"

 #include "Document.h"
 #include "RenderArena.h"
 #include "RenderBlock.h"
 #include "VisiblePosition.h"

 namespace WebCore {

 RenderInline::RenderInline(Node* node)
 :RenderFlow(node), m_isContinuation(false)
 {}

 RenderInline::~RenderInline()
 {}

 void RenderInline::setStyle(RenderStyle* _style)
 {
     RenderFlow::setStyle(_style);
     setInline(true);

     // 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.
     RenderFlow* currCont = continuation();
     while (currCont) {
         if (currCont->isInline()) {
             RenderFlow* nextCont = currCont->continuation();
             currCont->setContinuation(0);
             currCont->setStyle(style());
             currCont->setContinuation(nextCont);
         }
         currCont = currCont->continuation();
     }

     m_lineHeight = -1;

     // Update pseudos for :before and :after now.
     updatePseudoChild(RenderStyle::BEFORE);
     updatePseudoChild(RenderStyle::AFTER);
 }

 bool RenderInline::isInlineContinuation() const
 {
     return m_isContinuation;
 }

 void RenderInline::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild)
 {
     // Make sure we don't append things after :after-generated content if we have it.
     if (!beforeChild && lastChild() && lastChild()->style()->styleType() == RenderStyle::AFTER)
         beforeChild = lastChild();

     if (!newChild->isInline() && !newChild->isFloatingOrPositioned() && containingBlock()->isBlockFlow()) {
         // 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.
         RenderStyle *newStyle = new (renderArena()) RenderStyle();
         newStyle->inheritFrom(style());
         newStyle->setDisplay(BLOCK);

         RenderBlock *newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);
         newBox->setStyle(newStyle);
         RenderFlow* 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 updatePseudoChild to ensure that our :after
         // content gets properly destroyed.
         bool isLastChild = (beforeChild == lastChild());
         updatePseudoChild(RenderStyle::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;
     }

     RenderContainer::addChild(newChild,beforeChild);

     newChild->setNeedsLayoutAndMinMaxRecalc();
 }

 RenderInline* RenderInline::cloneInline(RenderFlow* src)
 {
     RenderInline *o = new (src->renderArena()) RenderInline(src->element());
     o->m_isContinuation = true;
     o->setStyle(src->style());
     return o;
 }

 void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
                                 RenderBlock* middleBlock,
                                 RenderObject* beforeChild, RenderFlow* 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->addChildToFlow(removeChildNode(tmp), 0);
         tmp->setNeedsLayoutAndMinMaxRecalc();
     }

     // Hook |clone| up as the continuation of the middle block.
     middleBlock->setContinuation(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.
     RenderFlow* curr = static_cast<RenderFlow*>(parent());
     RenderFlow* currChild = this;
     while (curr && curr != fromBlock) {
         // Create a new clone.
         RenderInline* cloneChild = clone;
         clone = cloneInline(curr);

         // Insert our child clone as the first child.
         clone->addChildToFlow(cloneChild, 0);

         // Hook the clone up as a continuation of |curr|.
         RenderFlow* oldCont = curr->continuation();
         curr->setContinuation(clone);
         clone->setContinuation(oldCont);

         // Someone may have indirectly caused a <q> to split.  When this happens, the :after content
         // has to move into the inline continuation.  Call updatePseudoChild to ensure that the inline's :after
         // content gets properly destroyed.
         curr->updatePseudoChild(RenderStyle::AFTER);

         // Now we need to take all of the children starting from the first child
         // *after* currChild and append them all to the clone.
         o = currChild->nextSibling();
         while (o) {
             RenderObject* tmp = o;
             o = tmp->nextSibling();
             clone->addChildToFlow(curr->removeChildNode(tmp), 0);
             tmp->setNeedsLayoutAndMinMaxRecalc();
         }

         // Keep walking up the chain.
         currChild = curr;
         curr = static_cast<RenderFlow*>(curr->parent());
     }

     // Now we are at the block level. We need to put the clone into the toBlock.
     toBlock->appendChildNode(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->appendChildNode(fromBlock->removeChildNode(tmp));
     }
 }

 void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
                              RenderObject* newChild, RenderFlow* oldCont)
 {
     RenderBlock* pre = 0;
     RenderBlock* block = containingBlock();
     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.
         pre = block;
         block = block->containingBlock();
     } else {
         // No anonymous block available for use.  Make one.
         pre = block->createAnonymousBlock();
         madeNewBeforeBlock = true;
     }

     RenderBlock* post = block->createAnonymousBlock();

     RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
     if (madeNewBeforeBlock)
         block->insertChildNode(pre, boxFirst);
     block->insertChildNode(newBlockBox, boxFirst);
     block->insertChildNode(post, boxFirst);
     block->setChildrenInline(false);

     if (madeNewBeforeBlock) {
         RenderObject* o = boxFirst;
         while (o)
         {
             RenderObject* no = o;
             o = no->nextSibling();
             pre->appendChildNode(block->removeChildNode(no));
             no->setNeedsLayoutAndMinMaxRecalc();
         }
     }

     splitInlines(pre, post, newBlockBox, beforeChild, oldCont);

     // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
     // time in makeChildrenNonInline by just setting this explicitly up front.
     newBlockBox->setChildrenInline(false);

     // We don't just call addChild, since it would pass things off to the
     // continuation, so we call addChildToFlow explicitly instead.  We delayed
     // adding the newChild until now so that the |newBlockBox| would be fully
     // connected, thus allowing newChild access to a renderArena should it need
     // to wrap itself in additional boxes (e.g., table construction).
     newBlockBox->addChildToFlow(newChild, 0);

     // 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->setNeedsLayoutAndMinMaxRecalc();
     block->setNeedsLayoutAndMinMaxRecalc();
     post->setNeedsLayoutAndMinMaxRecalc();
 }

 void RenderInline::paint(PaintInfo& i, int _tx, int _ty)
 {
     paintLines(i, _tx, _ty);
 }

 void RenderInline::absoluteRects(Vector<IntRect>& rects, int tx, int ty)
 {
     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->isText())
             curr->absoluteRects(rects, tx + curr->xPos(), ty + curr->yPos());

     if (continuation())
         continuation()->absoluteRects(rects,
                                       tx - containingBlock()->xPos() + continuation()->xPos(),
                                       ty - containingBlock()->yPos() + continuation()->yPos());
 }

 void RenderInline::calcMinMaxWidth()
 {
     ASSERT( !minMaxKnown() );

 #ifdef DEBUG_LAYOUT
     kdDebug( 6040 ) << renderName() << "(RenderInline)::calcMinMaxWidth() this=" << this << endl;
 #endif

     // Irrelevant, since some enclosing block will actually measure us and our children.
     m_minWidth = 0;
     m_maxWidth = 0;

     setMinMaxKnown();
 }

 bool RenderInline::requiresLayer() {
     return isRoot() || isRelPositioned() || style()->opacity() < 1.0f;
 }

 int RenderInline::width() const
 {
     // Return the width of the minimal left side and the maximal right side.
     int leftSide = 0;
     int rightSide = 0;
     for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
         if (curr == firstLineBox() || curr->xPos() < leftSide)
             leftSide = curr->xPos();
         if (curr == firstLineBox() || curr->xPos() + curr->width() > rightSide)
             rightSide = curr->xPos() + curr->width();
     }

     return rightSide - leftSide;
 }

 int RenderInline::height() const
 {
     int h = 0;
     if (firstLineBox())
         h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
     return h;
 }

 int RenderInline::offsetLeft() const
 {
     int x = RenderFlow::offsetLeft();
     if (firstLineBox())
         x += firstLineBox()->xPos();
     return x;
 }

 int RenderInline::offsetTop() const
 {
     int y = RenderFlow::offsetTop();
     if (firstLineBox())
         y += firstLineBox()->yPos();
     return y;
 }

 const char *RenderInline::renderName() const
 {
     if (isRelPositioned())
         return "RenderInline (relative positioned)";
     if (isAnonymous())
         return "RenderInline (generated)";
     return "RenderInline";
 }

 bool RenderInline::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty,
                                HitTestAction hitTestAction)
 {
     return hitTestLines(info, _x, _y, _tx, _ty, hitTestAction);
 }

 VisiblePosition RenderInline::positionForCoordinates(int x, int y)
 {
     for (RenderObject *c = continuation(); c; c = c->continuation()) {
         if (c->isInline() || c->firstChild())
             return c->positionForCoordinates(x, y);
     }

     return RenderFlow::positionForCoordinates(x, y);
 }

 }
	/*
	* 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
	* version 2 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Library General Public License for more details.
	*
	* You should have received a copy of the GNU Library General Public License
	* along with this library; see the file COPYING.LIB. If not, write to
	* the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	* Boston, MA 02111-1307, USA.
	*
	*/

	#include "config.h"
	#include "RenderInline.h"

	#include "Document.h"
	#include "RenderArena.h"
	#include "RenderBlock.h"
	#include "VisiblePosition.h"

	namespace WebCore {

	RenderInline::RenderInline(Node* node)
	:RenderFlow(node), m_isContinuation(false)
	{}

	RenderInline::~RenderInline()
	{}

	void RenderInline::setStyle(RenderStyle* _style)
	{
	RenderFlow::setStyle(_style);
	setInline(true);

	// 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.
	RenderFlow* currCont = continuation();
	while (currCont) {
	if (currCont->isInline()) {
	RenderFlow* nextCont = currCont->continuation();
	currCont->setContinuation(0);
	currCont->setStyle(style());
	currCont->setContinuation(nextCont);
	}
	currCont = currCont->continuation();
	}

	m_lineHeight = -1;

	// Update pseudos for :before and :after now.
	updatePseudoChild(RenderStyle::BEFORE);
	updatePseudoChild(RenderStyle::AFTER);
	}

	bool RenderInline::isInlineContinuation() const
	{
	return m_isContinuation;
	}

	void RenderInline::addChildToFlow(RenderObject* newChild, RenderObject* beforeChild)
	{
	// Make sure we don't append things after :after-generated content if we have it.
	if (!beforeChild && lastChild() && lastChild()->style()->styleType() == RenderStyle::AFTER)
	beforeChild = lastChild();

	if (!newChild->isInline() && !newChild->isFloatingOrPositioned() && containingBlock()->isBlockFlow()) {
	// 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.
	RenderStyle *newStyle = new (renderArena()) RenderStyle();
	newStyle->inheritFrom(style());
	newStyle->setDisplay(BLOCK);

	RenderBlock newBox = new (renderArena()) RenderBlock(document() / anonymous box */);
	newBox->setStyle(newStyle);
	RenderFlow* 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 updatePseudoChild to ensure that our :after
	// content gets properly destroyed.
	bool isLastChild = (beforeChild == lastChild());
	updatePseudoChild(RenderStyle::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;
	}

	RenderContainer::addChild(newChild,beforeChild);

	newChild->setNeedsLayoutAndMinMaxRecalc();
	}

	RenderInline* RenderInline::cloneInline(RenderFlow* src)
	{
	RenderInline *o = new (src->renderArena()) RenderInline(src->element());
	o->m_isContinuation = true;
	o->setStyle(src->style());
	return o;
	}

	void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
	RenderBlock* middleBlock,
	RenderObject* beforeChild, RenderFlow* 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->addChildToFlow(removeChildNode(tmp), 0);
	tmp->setNeedsLayoutAndMinMaxRecalc();
	}

	// Hook \|clone\| up as the continuation of the middle block.
	middleBlock->setContinuation(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.
	RenderFlow* curr = static_cast<RenderFlow*>(parent());
	RenderFlow* currChild = this;
	while (curr && curr != fromBlock) {
	// Create a new clone.
	RenderInline* cloneChild = clone;
	clone = cloneInline(curr);

	// Insert our child clone as the first child.
	clone->addChildToFlow(cloneChild, 0);

	// Hook the clone up as a continuation of \|curr\|.
	RenderFlow* oldCont = curr->continuation();
	curr->setContinuation(clone);
	clone->setContinuation(oldCont);

	// Someone may have indirectly caused a <q> to split. When this happens, the :after content
	// has to move into the inline continuation. Call updatePseudoChild to ensure that the inline's :after
	// content gets properly destroyed.
	curr->updatePseudoChild(RenderStyle::AFTER);

	// Now we need to take all of the children starting from the first child
	// after currChild and append them all to the clone.
	o = currChild->nextSibling();
	while (o) {
	RenderObject* tmp = o;
	o = tmp->nextSibling();
	clone->addChildToFlow(curr->removeChildNode(tmp), 0);
	tmp->setNeedsLayoutAndMinMaxRecalc();
	}

	// Keep walking up the chain.
	currChild = curr;
	curr = static_cast<RenderFlow*>(curr->parent());
	}

	// Now we are at the block level. We need to put the clone into the toBlock.
	toBlock->appendChildNode(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->appendChildNode(fromBlock->removeChildNode(tmp));
	}
	}

	void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
	RenderObject* newChild, RenderFlow* oldCont)
	{
	RenderBlock* pre = 0;
	RenderBlock* block = containingBlock();
	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.
	pre = block;
	block = block->containingBlock();
	} else {
	// No anonymous block available for use. Make one.
	pre = block->createAnonymousBlock();
	madeNewBeforeBlock = true;
	}

	RenderBlock* post = block->createAnonymousBlock();

	RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
	if (madeNewBeforeBlock)
	block->insertChildNode(pre, boxFirst);
	block->insertChildNode(newBlockBox, boxFirst);
	block->insertChildNode(post, boxFirst);
	block->setChildrenInline(false);

	if (madeNewBeforeBlock) {
	RenderObject* o = boxFirst;
	while (o)
	{
	RenderObject* no = o;
	o = no->nextSibling();
	pre->appendChildNode(block->removeChildNode(no));
	no->setNeedsLayoutAndMinMaxRecalc();
	}
	}

	splitInlines(pre, post, newBlockBox, beforeChild, oldCont);

	// We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
	// time in makeChildrenNonInline by just setting this explicitly up front.
	newBlockBox->setChildrenInline(false);

	// We don't just call addChild, since it would pass things off to the
	// continuation, so we call addChildToFlow explicitly instead. We delayed
	// adding the newChild until now so that the \|newBlockBox\| would be fully
	// connected, thus allowing newChild access to a renderArena should it need
	// to wrap itself in additional boxes (e.g., table construction).
	newBlockBox->addChildToFlow(newChild, 0);

	// 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->setNeedsLayoutAndMinMaxRecalc();
	block->setNeedsLayoutAndMinMaxRecalc();
	post->setNeedsLayoutAndMinMaxRecalc();
	}

	void RenderInline::paint(PaintInfo& i, int _tx, int _ty)
	{
	paintLines(i, _tx, _ty);
	}

	void RenderInline::absoluteRects(Vector<IntRect>& rects, int tx, int ty)
	{
	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->isText())
	curr->absoluteRects(rects, tx + curr->xPos(), ty + curr->yPos());

	if (continuation())
	continuation()->absoluteRects(rects,
	tx - containingBlock()->xPos() + continuation()->xPos(),
	ty - containingBlock()->yPos() + continuation()->yPos());
	}

	void RenderInline::calcMinMaxWidth()
	{
	ASSERT( !minMaxKnown() );

	#ifdef DEBUG_LAYOUT
	kdDebug( 6040 ) << renderName() << "(RenderInline)::calcMinMaxWidth() this=" << this << endl;
	#endif

	// Irrelevant, since some enclosing block will actually measure us and our children.
	m_minWidth = 0;
	m_maxWidth = 0;

	setMinMaxKnown();
	}

	bool RenderInline::requiresLayer() {
	return isRoot() \|\| isRelPositioned() \|\| style()->opacity() < 1.0f;
	}

	int RenderInline::width() const
	{
	// Return the width of the minimal left side and the maximal right side.
	int leftSide = 0;
	int rightSide = 0;
	for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
	if (curr == firstLineBox() \|\| curr->xPos() < leftSide)
	leftSide = curr->xPos();
	if (curr == firstLineBox() \|\| curr->xPos() + curr->width() > rightSide)
	rightSide = curr->xPos() + curr->width();
	}

	return rightSide - leftSide;
	}

	int RenderInline::height() const
	{
	int h = 0;
	if (firstLineBox())
	h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
	return h;
	}

	int RenderInline::offsetLeft() const
	{
	int x = RenderFlow::offsetLeft();
	if (firstLineBox())
	x += firstLineBox()->xPos();
	return x;
	}

	int RenderInline::offsetTop() const
	{
	int y = RenderFlow::offsetTop();
	if (firstLineBox())
	y += firstLineBox()->yPos();
	return y;
	}

	const char *RenderInline::renderName() const
	{
	if (isRelPositioned())
	return "RenderInline (relative positioned)";
	if (isAnonymous())
	return "RenderInline (generated)";
	return "RenderInline";
	}

	bool RenderInline::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty,
	HitTestAction hitTestAction)
	{
	return hitTestLines(info, _x, _y, _tx, _ty, hitTestAction);
	}

	VisiblePosition RenderInline::positionForCoordinates(int x, int y)
	{
	for (RenderObject *c = continuation(); c; c = c->continuation()) {
	if (c->isInline() \|\| c->firstChild())
	return c->positionForCoordinates(x, y);
	}

	return RenderFlow::positionForCoordinates(x, y);
	}

	}