WebCore/rendering/SVGTextQuery.cpp - platform/external/webkit - Git at Google

 /*
     Copyright (C) Research In Motion Limited 2010. All rights reserved.

     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.

     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.

     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */

 #include "config.h"
 #include "SVGTextQuery.h"

 #if ENABLE(SVG)
 #include "FloatConversion.h"
 #include "InlineFlowBox.h"
 #include "RenderBlock.h"
 #include "RenderInline.h"
 #include "SVGInlineTextBox.h"
 #include "VisiblePosition.h"

 namespace WebCore {

 // Base structure for callback user data
 struct SVGTextQuery::Data {
     Data()
         : processedChunkCharacters(0)
     {
     }

     unsigned processedChunkCharacters;
 };

 static inline InlineFlowBox* flowBoxForRenderer(RenderObject* renderer)
 {
     if (!renderer)
         return 0;

     if (renderer->isRenderBlock()) {
         // If we're given a block element, it has to be a RenderSVGText.
         ASSERT(renderer->isSVGText());
         RenderBlock* renderBlock = toRenderBlock(renderer);

         // RenderSVGText only ever contains a single line box.
         InlineFlowBox* flowBox = renderBlock->firstLineBox();
         ASSERT(flowBox == renderBlock->lastLineBox());
         return flowBox;
     }

     if (renderer->isRenderInline()) {
         // We're given a RenderSVGInline or objects that derive from it (RenderSVGTSpan / RenderSVGTextPath)
         RenderInline* renderInline = toRenderInline(renderer);

         // RenderSVGInline only ever contains a single line box.
         InlineFlowBox* flowBox = renderInline->firstLineBox();
         ASSERT(flowBox == renderInline->lastLineBox());
         return flowBox;
     }

     ASSERT_NOT_REACHED();
     return 0;
 }

 static inline float mapLengthThroughChunkTransformation(const SVGInlineTextBox* textBox, bool isVerticalText, float length)
 {
     const AffineTransform& transform = textBox->chunkTransformation();
     if (transform.isIdentity())
         return length;

     return narrowPrecisionToFloat(static_cast<double>(length) * (isVerticalText ? transform.d() : transform.a()));
 }

 SVGTextQuery::SVGTextQuery(RenderObject* renderer)
 {
     collectTextBoxesInFlowBox(flowBoxForRenderer(renderer));
 }

 void SVGTextQuery::collectTextBoxesInFlowBox(InlineFlowBox* flowBox)
 {
     if (!flowBox)
         return;

     for (InlineBox* child = flowBox->firstChild(); child; child = child->nextOnLine()) {
         if (child->isInlineFlowBox()) {
             // Skip generated content.
             if (!child->renderer()->node())
                 continue;

             collectTextBoxesInFlowBox(static_cast<InlineFlowBox*>(child));
             continue;
         }

         ASSERT(child->isSVGInlineTextBox());
         m_textBoxes.append(static_cast<SVGInlineTextBox*>(child));
     }
 }

 bool SVGTextQuery::executeQuery(Data* queryData, ProcessTextChunkPartCallback chunkPartCallback) const
 {
     ASSERT(!m_textBoxes.isEmpty());
     bool finished = false;

     // Loop over all text boxes
     const Vector<SVGInlineTextBox*>::const_iterator end = m_textBoxes.end();
     for (Vector<SVGInlineTextBox*>::const_iterator it = m_textBoxes.begin(); it != end; ++it) {
         const SVGInlineTextBox* textBox = *it;
         const Vector<SVGTextChunkPart>& parts = textBox->svgTextChunkParts();

         int processedCharacters = 0;

         // Loop over all text chunk parts in this text box, firing a callback for each chunk part.
         const Vector<SVGTextChunkPart>::const_iterator partEnd = parts.end();
         for (Vector<SVGTextChunkPart>::const_iterator partIt = parts.begin(); partIt != partEnd; ++partIt) {
             if ((this->*chunkPartCallback)(queryData, textBox, *partIt)) {
                 finished = true;
                 break;
             }

             processedCharacters += partIt->length;
         }

         if (finished)
             break;

         queryData->processedChunkCharacters += processedCharacters;
     }

     return finished;
 }

 bool SVGTextQuery::mapStartAndLengthIntoChunkPartCoordinates(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part, int& startPosition, int& endPosition) const
 {
     // Reuse the same logic used for text selection & painting, to map our query start/length into start/endPositions of the current text chunk part.
     startPosition -= queryData->processedChunkCharacters;
     endPosition -= queryData->processedChunkCharacters;
     textBox->mapStartEndPositionsIntoChunkPartCoordinates(startPosition, endPosition, part);

     // If startPosition < endPosition, then the position we're supposed to measure lies in this chunk part.
     return startPosition < endPosition;
 }

 float SVGTextQuery::measureCharacterRange(const SVGInlineTextBox* textBox, RenderStyle* style, bool isVerticalText, int startPosition, int length) const
 {
     // FIXME: Vertical writing mode needs to be handled more accurate.
     if (isVerticalText)
         return length * style->font().height();

     const UChar* startCharacter = textBox->textRenderer()->characters() + textBox->start() + startPosition;
     return style->font().floatWidth(svgTextRunForInlineTextBox(startCharacter, length, style, textBox));
 }

 // numberOfCharacters() implementation
 struct NumberOfCharactersData : SVGTextQuery::Data {
     NumberOfCharactersData()
         : characters(0)
     {
     }

     unsigned characters;
 };

 bool SVGTextQuery::numberOfCharactersCallback(Data* queryData, const SVGInlineTextBox*, const SVGTextChunkPart& part) const
 {
     NumberOfCharactersData* data = static_cast<NumberOfCharactersData*>(queryData);
     data->characters += part.length;
     return false;
 }

 unsigned SVGTextQuery::numberOfCharacters() const
 {
     if (m_textBoxes.isEmpty())
         return 0;

     NumberOfCharactersData data;
     executeQuery(&data, &SVGTextQuery::numberOfCharactersCallback);
     return data.characters;
 }

 // textLength() implementation
 struct TextLengthData : SVGTextQuery::Data {
     TextLengthData()
         : textLength(0.0f)
     {
     }

     float textLength;
 };

 bool SVGTextQuery::textLengthCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     TextLengthData* data = static_cast<TextLengthData*>(queryData);

     RenderStyle* style = textBox->textRenderer()->style();
     ASSERT(style);

     bool isVerticalText = isVerticalWritingMode(style->svgStyle());
     float partLength = isVerticalText ? part.height : part.width;

     data->textLength += mapLengthThroughChunkTransformation(textBox, isVerticalText, partLength);
     return false;
 }

 float SVGTextQuery::textLength() const
 {
     if (m_textBoxes.isEmpty())
         return 0.0f;

     TextLengthData data;
     executeQuery(&data, &SVGTextQuery::textLengthCallback);
     return data.textLength;
 }

 // subStringLength() implementation
 struct SubStringLengthData : SVGTextQuery::Data {
     SubStringLengthData(unsigned queryStartPosition, unsigned queryLength)
         : startPosition(queryStartPosition)
         , length(queryLength)
         , subStringLength(0.0f)
     {
     }

     unsigned startPosition;
     unsigned length;

     float subStringLength;
 };

 bool SVGTextQuery::subStringLengthCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     SubStringLengthData* data = static_cast<SubStringLengthData*>(queryData);

     int startPosition = data->startPosition;
     int endPosition = startPosition + data->length;
     if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
         return false;

     RenderStyle* style = textBox->textRenderer()->style();
     ASSERT(style);

     bool isVerticalText = isVerticalWritingMode(style->svgStyle());
     float partLength = measureCharacterRange(textBox, style, isVerticalWritingMode(style->svgStyle()), part.offset + startPosition, endPosition - startPosition);

     data->subStringLength += mapLengthThroughChunkTransformation(textBox, isVerticalText, partLength);
     return false;
 }

 float SVGTextQuery::subStringLength(unsigned startPosition, unsigned length) const
 {
     if (m_textBoxes.isEmpty())
         return 0.0f;

     SubStringLengthData data(startPosition, length);
     executeQuery(&data, &SVGTextQuery::subStringLengthCallback);
     return data.subStringLength;
 }

 // startPositionOfCharacter() implementation
 struct StartPositionOfCharacterData : SVGTextQuery::Data {
     StartPositionOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }

     unsigned position;
     FloatPoint startPosition;
 };

 bool SVGTextQuery::startPositionOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     StartPositionOfCharacterData* data = static_cast<StartPositionOfCharacterData*>(queryData);

     int startPosition = data->position;
     int endPosition = startPosition + 1;
     if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
         return false;

     const SVGChar& character = *(part.firstCharacter + startPosition);
     data->startPosition = textBox->chunkTransformation().mapPoint(FloatPoint(character.x, character.y));
     return true;
 }

 FloatPoint SVGTextQuery::startPositionOfCharacter(unsigned position) const
 {
     if (m_textBoxes.isEmpty())
         return FloatPoint();

     StartPositionOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::startPositionOfCharacterCallback);
     return data.startPosition;
 }

 // endPositionOfCharacter() implementation
 struct EndPositionOfCharacterData : SVGTextQuery::Data {
     EndPositionOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }

     unsigned position;
     FloatPoint endPosition;
 };

 bool SVGTextQuery::endPositionOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     EndPositionOfCharacterData* data = static_cast<EndPositionOfCharacterData*>(queryData);

     int startPosition = data->position;
     int endPosition = startPosition + 1;
     if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
         return false;

     const SVGChar& character = *(part.firstCharacter + startPosition);
     data->endPosition = FloatPoint(character.x, character.y);

     RenderStyle* style = textBox->textRenderer()->style();
     ASSERT(style);

     bool isVerticalText = isVerticalWritingMode(style->svgStyle());
     float glyphAdvance = measureCharacterRange(textBox, style, isVerticalText, part.offset + startPosition, 1);

     if (isVerticalText)
         data->endPosition.move(0.0f, glyphAdvance);
     else
         data->endPosition.move(glyphAdvance, 0.0f);

     data->endPosition = textBox->chunkTransformation().mapPoint(data->endPosition);
     return true;
 }

 FloatPoint SVGTextQuery::endPositionOfCharacter(unsigned position) const
 {
     if (m_textBoxes.isEmpty())
         return FloatPoint();

     EndPositionOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::endPositionOfCharacterCallback);
     return data.endPosition;
 }

 // rotationOfCharacter() implementation
 struct RotationOfCharacterData : SVGTextQuery::Data {
     RotationOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
         , rotation(0.0f)
     {
     }

     unsigned position;
     float rotation;
 };

 bool SVGTextQuery::rotationOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     RotationOfCharacterData* data = static_cast<RotationOfCharacterData*>(queryData);

     int startPosition = data->position;
     int endPosition = startPosition + 1;
     if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
         return false;

     const SVGChar& character = *(part.firstCharacter + startPosition);
     data->rotation = character.angle;
     return true;
 }

 float SVGTextQuery::rotationOfCharacter(unsigned position) const
 {
     if (m_textBoxes.isEmpty())
         return 0.0f;

     RotationOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::rotationOfCharacterCallback);
     return data.rotation;
 }

 // extentOfCharacter() implementation
 struct ExtentOfCharacterData : SVGTextQuery::Data {
     ExtentOfCharacterData(unsigned queryPosition)
         : position(queryPosition)
     {
     }

     unsigned position;
     FloatRect extent;
 };

 bool SVGTextQuery::extentOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     ExtentOfCharacterData* data = static_cast<ExtentOfCharacterData*>(queryData);

     int startPosition = data->position;
     int endPosition = startPosition + 1;
     if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
         return false;

     RenderStyle* style = textBox->textRenderer()->style();
     ASSERT(style);

     const SVGChar& character = *(part.firstCharacter + startPosition);
     data->extent = textBox->calculateGlyphBoundaries(style, part.offset + startPosition, character);
     return true;
 }

 FloatRect SVGTextQuery::extentOfCharacter(unsigned position) const
 {
     if (m_textBoxes.isEmpty())
         return FloatRect();

     ExtentOfCharacterData data(position);
     executeQuery(&data, &SVGTextQuery::extentOfCharacterCallback);
     return data.extent;
 }

 // characterNumberAtPosition() implementation
 struct CharacterNumberAtPositionData : SVGTextQuery::Data {
     CharacterNumberAtPositionData(const FloatPoint& queryPosition)
         : characterNumber(0)
         , position(queryPosition)
     {
     }

     unsigned characterNumber;
     FloatPoint position;
 };

 bool SVGTextQuery::characterNumberAtPositionCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
 {
     CharacterNumberAtPositionData* data = static_cast<CharacterNumberAtPositionData*>(queryData);

     RenderStyle* style = textBox->textRenderer()->style();
     ASSERT(style);

     for (int i = 0; i < part.length; ++i) {
         FloatRect extent(textBox->calculateGlyphBoundaries(style, part.offset + i, *(part.firstCharacter + i)));
         if (extent.contains(data->position))
             return true;

         ++data->characterNumber;
     }

     return false;
 }

 int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const
 {
     if (m_textBoxes.isEmpty())
         return -1;

     CharacterNumberAtPositionData data(position);
     if (!executeQuery(&data, &SVGTextQuery::characterNumberAtPositionCallback))
         return -1;

     return data.characterNumber;
 }

 }

 #endif
	/*
	Copyright (C) Research In Motion Limited 2010. All rights reserved.

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.

	You should have received a copy of the GNU Library General Public License
	along with this library; see the file COPYING.LIB. If not, write to
	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA.
	*/

	#include "config.h"
	#include "SVGTextQuery.h"

	#if ENABLE(SVG)
	#include "FloatConversion.h"
	#include "InlineFlowBox.h"
	#include "RenderBlock.h"
	#include "RenderInline.h"
	#include "SVGInlineTextBox.h"
	#include "VisiblePosition.h"

	namespace WebCore {

	// Base structure for callback user data
	struct SVGTextQuery::Data {
	Data()
	: processedChunkCharacters(0)
	{
	}

	unsigned processedChunkCharacters;
	};

	static inline InlineFlowBox* flowBoxForRenderer(RenderObject* renderer)
	{
	if (!renderer)
	return 0;

	if (renderer->isRenderBlock()) {
	// If we're given a block element, it has to be a RenderSVGText.
	ASSERT(renderer->isSVGText());
	RenderBlock* renderBlock = toRenderBlock(renderer);

	// RenderSVGText only ever contains a single line box.
	InlineFlowBox* flowBox = renderBlock->firstLineBox();
	ASSERT(flowBox == renderBlock->lastLineBox());
	return flowBox;
	}

	if (renderer->isRenderInline()) {
	// We're given a RenderSVGInline or objects that derive from it (RenderSVGTSpan / RenderSVGTextPath)
	RenderInline* renderInline = toRenderInline(renderer);

	// RenderSVGInline only ever contains a single line box.
	InlineFlowBox* flowBox = renderInline->firstLineBox();
	ASSERT(flowBox == renderInline->lastLineBox());
	return flowBox;
	}

	ASSERT_NOT_REACHED();
	return 0;
	}

	static inline float mapLengthThroughChunkTransformation(const SVGInlineTextBox* textBox, bool isVerticalText, float length)
	{
	const AffineTransform& transform = textBox->chunkTransformation();
	if (transform.isIdentity())
	return length;

	return narrowPrecisionToFloat(static_cast<double>(length) * (isVerticalText ? transform.d() : transform.a()));
	}

	SVGTextQuery::SVGTextQuery(RenderObject* renderer)
	{
	collectTextBoxesInFlowBox(flowBoxForRenderer(renderer));
	}

	void SVGTextQuery::collectTextBoxesInFlowBox(InlineFlowBox* flowBox)
	{
	if (!flowBox)
	return;

	for (InlineBox* child = flowBox->firstChild(); child; child = child->nextOnLine()) {
	if (child->isInlineFlowBox()) {
	// Skip generated content.
	if (!child->renderer()->node())
	continue;

	collectTextBoxesInFlowBox(static_cast<InlineFlowBox*>(child));
	continue;
	}

	ASSERT(child->isSVGInlineTextBox());
	m_textBoxes.append(static_cast<SVGInlineTextBox*>(child));
	}
	}

	bool SVGTextQuery::executeQuery(Data* queryData, ProcessTextChunkPartCallback chunkPartCallback) const
	{
	ASSERT(!m_textBoxes.isEmpty());
	bool finished = false;

	// Loop over all text boxes
	const Vector<SVGInlineTextBox*>::const_iterator end = m_textBoxes.end();
	for (Vector<SVGInlineTextBox*>::const_iterator it = m_textBoxes.begin(); it != end; ++it) {
	const SVGInlineTextBox* textBox = *it;
	const Vector<SVGTextChunkPart>& parts = textBox->svgTextChunkParts();

	int processedCharacters = 0;

	// Loop over all text chunk parts in this text box, firing a callback for each chunk part.
	const Vector<SVGTextChunkPart>::const_iterator partEnd = parts.end();
	for (Vector<SVGTextChunkPart>::const_iterator partIt = parts.begin(); partIt != partEnd; ++partIt) {
	if ((this->chunkPartCallback)(queryData, textBox, partIt)) {
	finished = true;
	break;
	}

	processedCharacters += partIt->length;
	}

	if (finished)
	break;

	queryData->processedChunkCharacters += processedCharacters;
	}

	return finished;
	}

	bool SVGTextQuery::mapStartAndLengthIntoChunkPartCoordinates(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part, int& startPosition, int& endPosition) const
	{
	// Reuse the same logic used for text selection & painting, to map our query start/length into start/endPositions of the current text chunk part.
	startPosition -= queryData->processedChunkCharacters;
	endPosition -= queryData->processedChunkCharacters;
	textBox->mapStartEndPositionsIntoChunkPartCoordinates(startPosition, endPosition, part);

	// If startPosition < endPosition, then the position we're supposed to measure lies in this chunk part.
	return startPosition < endPosition;
	}

	float SVGTextQuery::measureCharacterRange(const SVGInlineTextBox* textBox, RenderStyle* style, bool isVerticalText, int startPosition, int length) const
	{
	// FIXME: Vertical writing mode needs to be handled more accurate.
	if (isVerticalText)
	return length * style->font().height();

	const UChar* startCharacter = textBox->textRenderer()->characters() + textBox->start() + startPosition;
	return style->font().floatWidth(svgTextRunForInlineTextBox(startCharacter, length, style, textBox));
	}

	// numberOfCharacters() implementation
	struct NumberOfCharactersData : SVGTextQuery::Data {
	NumberOfCharactersData()
	: characters(0)
	{
	}

	unsigned characters;
	};

	bool SVGTextQuery::numberOfCharactersCallback(Data* queryData, const SVGInlineTextBox*, const SVGTextChunkPart& part) const
	{
	NumberOfCharactersData* data = static_cast<NumberOfCharactersData*>(queryData);
	data->characters += part.length;
	return false;
	}

	unsigned SVGTextQuery::numberOfCharacters() const
	{
	if (m_textBoxes.isEmpty())
	return 0;

	NumberOfCharactersData data;
	executeQuery(&data, &SVGTextQuery::numberOfCharactersCallback);
	return data.characters;
	}

	// textLength() implementation
	struct TextLengthData : SVGTextQuery::Data {
	TextLengthData()
	: textLength(0.0f)
	{
	}

	float textLength;
	};

	bool SVGTextQuery::textLengthCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	TextLengthData* data = static_cast<TextLengthData*>(queryData);

	RenderStyle* style = textBox->textRenderer()->style();
	ASSERT(style);

	bool isVerticalText = isVerticalWritingMode(style->svgStyle());
	float partLength = isVerticalText ? part.height : part.width;

	data->textLength += mapLengthThroughChunkTransformation(textBox, isVerticalText, partLength);
	return false;
	}

	float SVGTextQuery::textLength() const
	{
	if (m_textBoxes.isEmpty())
	return 0.0f;

	TextLengthData data;
	executeQuery(&data, &SVGTextQuery::textLengthCallback);
	return data.textLength;
	}

	// subStringLength() implementation
	struct SubStringLengthData : SVGTextQuery::Data {
	SubStringLengthData(unsigned queryStartPosition, unsigned queryLength)
	: startPosition(queryStartPosition)
	, length(queryLength)
	, subStringLength(0.0f)
	{
	}

	unsigned startPosition;
	unsigned length;

	float subStringLength;
	};

	bool SVGTextQuery::subStringLengthCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	SubStringLengthData* data = static_cast<SubStringLengthData*>(queryData);

	int startPosition = data->startPosition;
	int endPosition = startPosition + data->length;
	if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
	return false;

	RenderStyle* style = textBox->textRenderer()->style();
	ASSERT(style);

	bool isVerticalText = isVerticalWritingMode(style->svgStyle());
	float partLength = measureCharacterRange(textBox, style, isVerticalWritingMode(style->svgStyle()), part.offset + startPosition, endPosition - startPosition);

	data->subStringLength += mapLengthThroughChunkTransformation(textBox, isVerticalText, partLength);
	return false;
	}

	float SVGTextQuery::subStringLength(unsigned startPosition, unsigned length) const
	{
	if (m_textBoxes.isEmpty())
	return 0.0f;

	SubStringLengthData data(startPosition, length);
	executeQuery(&data, &SVGTextQuery::subStringLengthCallback);
	return data.subStringLength;
	}

	// startPositionOfCharacter() implementation
	struct StartPositionOfCharacterData : SVGTextQuery::Data {
	StartPositionOfCharacterData(unsigned queryPosition)
	: position(queryPosition)
	{
	}

	unsigned position;
	FloatPoint startPosition;
	};

	bool SVGTextQuery::startPositionOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	StartPositionOfCharacterData* data = static_cast<StartPositionOfCharacterData*>(queryData);

	int startPosition = data->position;
	int endPosition = startPosition + 1;
	if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
	return false;

	const SVGChar& character = *(part.firstCharacter + startPosition);
	data->startPosition = textBox->chunkTransformation().mapPoint(FloatPoint(character.x, character.y));
	return true;
	}

	FloatPoint SVGTextQuery::startPositionOfCharacter(unsigned position) const
	{
	if (m_textBoxes.isEmpty())
	return FloatPoint();

	StartPositionOfCharacterData data(position);
	executeQuery(&data, &SVGTextQuery::startPositionOfCharacterCallback);
	return data.startPosition;
	}

	// endPositionOfCharacter() implementation
	struct EndPositionOfCharacterData : SVGTextQuery::Data {
	EndPositionOfCharacterData(unsigned queryPosition)
	: position(queryPosition)
	{
	}

	unsigned position;
	FloatPoint endPosition;
	};

	bool SVGTextQuery::endPositionOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	EndPositionOfCharacterData* data = static_cast<EndPositionOfCharacterData*>(queryData);

	int startPosition = data->position;
	int endPosition = startPosition + 1;
	if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
	return false;

	const SVGChar& character = *(part.firstCharacter + startPosition);
	data->endPosition = FloatPoint(character.x, character.y);

	RenderStyle* style = textBox->textRenderer()->style();
	ASSERT(style);

	bool isVerticalText = isVerticalWritingMode(style->svgStyle());
	float glyphAdvance = measureCharacterRange(textBox, style, isVerticalText, part.offset + startPosition, 1);

	if (isVerticalText)
	data->endPosition.move(0.0f, glyphAdvance);
	else
	data->endPosition.move(glyphAdvance, 0.0f);

	data->endPosition = textBox->chunkTransformation().mapPoint(data->endPosition);
	return true;
	}

	FloatPoint SVGTextQuery::endPositionOfCharacter(unsigned position) const
	{
	if (m_textBoxes.isEmpty())
	return FloatPoint();

	EndPositionOfCharacterData data(position);
	executeQuery(&data, &SVGTextQuery::endPositionOfCharacterCallback);
	return data.endPosition;
	}

	// rotationOfCharacter() implementation
	struct RotationOfCharacterData : SVGTextQuery::Data {
	RotationOfCharacterData(unsigned queryPosition)
	: position(queryPosition)
	, rotation(0.0f)
	{
	}

	unsigned position;
	float rotation;
	};

	bool SVGTextQuery::rotationOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	RotationOfCharacterData* data = static_cast<RotationOfCharacterData*>(queryData);

	int startPosition = data->position;
	int endPosition = startPosition + 1;
	if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
	return false;

	const SVGChar& character = *(part.firstCharacter + startPosition);
	data->rotation = character.angle;
	return true;
	}

	float SVGTextQuery::rotationOfCharacter(unsigned position) const
	{
	if (m_textBoxes.isEmpty())
	return 0.0f;

	RotationOfCharacterData data(position);
	executeQuery(&data, &SVGTextQuery::rotationOfCharacterCallback);
	return data.rotation;
	}

	// extentOfCharacter() implementation
	struct ExtentOfCharacterData : SVGTextQuery::Data {
	ExtentOfCharacterData(unsigned queryPosition)
	: position(queryPosition)
	{
	}

	unsigned position;
	FloatRect extent;
	};

	bool SVGTextQuery::extentOfCharacterCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	ExtentOfCharacterData* data = static_cast<ExtentOfCharacterData*>(queryData);

	int startPosition = data->position;
	int endPosition = startPosition + 1;
	if (!mapStartAndLengthIntoChunkPartCoordinates(queryData, textBox, part, startPosition, endPosition))
	return false;

	RenderStyle* style = textBox->textRenderer()->style();
	ASSERT(style);

	const SVGChar& character = *(part.firstCharacter + startPosition);
	data->extent = textBox->calculateGlyphBoundaries(style, part.offset + startPosition, character);
	return true;
	}

	FloatRect SVGTextQuery::extentOfCharacter(unsigned position) const
	{
	if (m_textBoxes.isEmpty())
	return FloatRect();

	ExtentOfCharacterData data(position);
	executeQuery(&data, &SVGTextQuery::extentOfCharacterCallback);
	return data.extent;
	}

	// characterNumberAtPosition() implementation
	struct CharacterNumberAtPositionData : SVGTextQuery::Data {
	CharacterNumberAtPositionData(const FloatPoint& queryPosition)
	: characterNumber(0)
	, position(queryPosition)
	{
	}

	unsigned characterNumber;
	FloatPoint position;
	};

	bool SVGTextQuery::characterNumberAtPositionCallback(Data* queryData, const SVGInlineTextBox* textBox, const SVGTextChunkPart& part) const
	{
	CharacterNumberAtPositionData* data = static_cast<CharacterNumberAtPositionData*>(queryData);

	RenderStyle* style = textBox->textRenderer()->style();
	ASSERT(style);

	for (int i = 0; i < part.length; ++i) {
	FloatRect extent(textBox->calculateGlyphBoundaries(style, part.offset + i, *(part.firstCharacter + i)));
	if (extent.contains(data->position))
	return true;

	++data->characterNumber;
	}

	return false;
	}

	int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const
	{
	if (m_textBoxes.isEmpty())
	return -1;

	CharacterNumberAtPositionData data(position);
	if (!executeQuery(&data, &SVGTextQuery::characterNumberAtPositionCallback))
	return -1;

	return data.characterNumber;
	}

	}

	#endif