/* | |
Copyright (C) 2004, 2005, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org> | |
2004, 2005, 2006, 2007, 2008 Rob Buis <buis@kde.org> | |
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" | |
#if ENABLE(SVG) | |
#include "SVGTextContentElement.h" | |
#include "CSSPropertyNames.h" | |
#include "CSSValueKeywords.h" | |
#include "ExceptionCode.h" | |
#include "FloatPoint.h" | |
#include "FloatRect.h" | |
#include "Frame.h" | |
#include "MappedAttribute.h" | |
#include "Position.h" | |
#include "RenderSVGText.h" | |
#include "SVGCharacterLayoutInfo.h" | |
#include "SVGInlineTextBox.h" | |
#include "SVGLength.h" | |
#include "SVGNames.h" | |
#include "SVGRootInlineBox.h" | |
#include "SelectionController.h" | |
#include "XMLNames.h" | |
#include <wtf/StdLibExtras.h> | |
namespace WebCore { | |
SVGTextContentElement::SVGTextContentElement(const QualifiedName& tagName, Document* doc) | |
: SVGStyledElement(tagName, doc) | |
, SVGTests() | |
, SVGLangSpace() | |
, SVGExternalResourcesRequired() | |
, m_textLength(LengthModeOther) | |
, m_lengthAdjust(LENGTHADJUST_SPACING) | |
{ | |
} | |
SVGTextContentElement::~SVGTextContentElement() | |
{ | |
} | |
static inline float cumulativeCharacterRangeLength(const Vector<SVGChar>::iterator& start, const Vector<SVGChar>::iterator& end, SVGInlineTextBox* textBox, | |
int startOffset, long startPosition, long length, bool isVerticalText, long& atCharacter) | |
{ | |
if (!length) | |
return 0.0f; | |
float textLength = 0.0f; | |
RenderStyle* style = textBox->textRenderer()->style(); | |
bool usesFullRange = (startPosition == -1 && length == -1); | |
for (Vector<SVGChar>::iterator it = start; it != end; ++it) { | |
if (usesFullRange || (atCharacter >= startPosition && atCharacter <= startPosition + length)) { | |
unsigned int newOffset = textBox->start() + (it - start) + startOffset; | |
// Take RTL text into account and pick right glyph width/height. | |
if (textBox->direction() == RTL) | |
newOffset = textBox->start() + textBox->end() - newOffset; | |
// FIXME: does this handle multichar glyphs ok? not sure | |
int charsConsumed = 0; | |
String glyphName; | |
if (isVerticalText) | |
textLength += textBox->calculateGlyphHeight(style, newOffset, 0); | |
else | |
textLength += textBox->calculateGlyphWidth(style, newOffset, 0, charsConsumed, glyphName); | |
} | |
if (!usesFullRange) { | |
if (atCharacter == startPosition + length - 1) | |
break; | |
atCharacter++; | |
} | |
} | |
return textLength; | |
} | |
// Helper class for querying certain glyph information | |
struct SVGInlineTextBoxQueryWalker { | |
typedef enum { | |
NumberOfCharacters, | |
TextLength, | |
SubStringLength, | |
StartPosition, | |
EndPosition, | |
Extent, | |
Rotation, | |
CharacterNumberAtPosition | |
} QueryMode; | |
SVGInlineTextBoxQueryWalker(const SVGTextContentElement* reference, QueryMode mode) | |
: m_reference(reference) | |
, m_mode(mode) | |
, m_queryStartPosition(0) | |
, m_queryLength(0) | |
, m_queryPointInput() | |
, m_queryLongResult(0) | |
, m_queryFloatResult(0.0f) | |
, m_queryPointResult() | |
, m_queryRectResult() | |
, m_stopProcessing(true) | |
, m_atCharacter(0) | |
{ | |
} | |
void chunkPortionCallback(SVGInlineTextBox* textBox, int startOffset, const AffineTransform&, | |
const Vector<SVGChar>::iterator& start, const Vector<SVGChar>::iterator& end) | |
{ | |
RenderStyle* style = textBox->textRenderer()->style(); | |
bool isVerticalText = style->svgStyle()->writingMode() == WM_TBRL || style->svgStyle()->writingMode() == WM_TB; | |
switch (m_mode) { | |
case NumberOfCharacters: | |
{ | |
m_queryLongResult += (end - start); | |
m_stopProcessing = false; | |
return; | |
} | |
case TextLength: | |
{ | |
float textLength = cumulativeCharacterRangeLength(start, end, textBox, startOffset, -1, -1, isVerticalText, m_atCharacter); | |
if (isVerticalText) | |
m_queryFloatResult += textLength; | |
else | |
m_queryFloatResult += textLength; | |
m_stopProcessing = false; | |
return; | |
} | |
case SubStringLength: | |
{ | |
long startPosition = m_queryStartPosition; | |
long length = m_queryLength; | |
float textLength = cumulativeCharacterRangeLength(start, end, textBox, startOffset, startPosition, length, isVerticalText, m_atCharacter); | |
if (isVerticalText) | |
m_queryFloatResult += textLength; | |
else | |
m_queryFloatResult += textLength; | |
if (m_atCharacter == startPosition + length) | |
m_stopProcessing = true; | |
else | |
m_stopProcessing = false; | |
return; | |
} | |
case StartPosition: | |
{ | |
for (Vector<SVGChar>::iterator it = start; it != end; ++it) { | |
if (m_atCharacter == m_queryStartPosition) { | |
m_queryPointResult = FloatPoint(it->x, it->y); | |
m_stopProcessing = true; | |
return; | |
} | |
m_atCharacter++; | |
} | |
m_stopProcessing = false; | |
return; | |
} | |
case EndPosition: | |
{ | |
for (Vector<SVGChar>::iterator it = start; it != end; ++it) { | |
if (m_atCharacter == m_queryStartPosition) { | |
unsigned int newOffset = textBox->start() + (it - start) + startOffset; | |
// Take RTL text into account and pick right glyph width/height. | |
if (textBox->direction() == RTL) | |
newOffset = textBox->start() + textBox->end() - newOffset; | |
int charsConsumed; | |
String glyphName; | |
// calculateGlyph{Height,Width} will consume at least one character. This is the number of characters available | |
// to them beyond that first one. | |
int extraCharactersAvailable = end - it - 1; | |
if (isVerticalText) | |
m_queryPointResult.move(it->x, it->y + textBox->calculateGlyphHeight(style, newOffset, extraCharactersAvailable)); | |
else | |
m_queryPointResult.move(it->x + textBox->calculateGlyphWidth(style, newOffset, extraCharactersAvailable, charsConsumed, glyphName), it->y); | |
m_stopProcessing = true; | |
return; | |
} | |
m_atCharacter++; | |
} | |
m_stopProcessing = false; | |
return; | |
} | |
case Extent: | |
{ | |
for (Vector<SVGChar>::iterator it = start; it != end; ++it) { | |
if (m_atCharacter == m_queryStartPosition) { | |
unsigned int newOffset = textBox->start() + (it - start) + startOffset; | |
m_queryRectResult = textBox->calculateGlyphBoundaries(style, newOffset, *it); | |
m_stopProcessing = true; | |
return; | |
} | |
m_atCharacter++; | |
} | |
m_stopProcessing = false; | |
return; | |
} | |
case Rotation: | |
{ | |
for (Vector<SVGChar>::iterator it = start; it != end; ++it) { | |
if (m_atCharacter == m_queryStartPosition) { | |
m_queryFloatResult = it->angle; | |
m_stopProcessing = true; | |
return; | |
} | |
m_atCharacter++; | |
} | |
m_stopProcessing = false; | |
return; | |
} | |
case CharacterNumberAtPosition: | |
{ | |
int offset = 0; | |
SVGChar* charAtPos = textBox->closestCharacterToPosition(m_queryPointInput.x(), m_queryPointInput.y(), offset); | |
offset += m_atCharacter; | |
if (charAtPos && offset > m_queryLongResult) | |
m_queryLongResult = offset; | |
m_atCharacter += end - start; | |
m_stopProcessing = false; | |
return; | |
} | |
default: | |
ASSERT_NOT_REACHED(); | |
m_stopProcessing = true; | |
return; | |
} | |
} | |
void setQueryInputParameters(long startPosition, long length, FloatPoint referencePoint) | |
{ | |
m_queryStartPosition = startPosition; | |
m_queryLength = length; | |
m_queryPointInput = referencePoint; | |
} | |
long longResult() const { return m_queryLongResult; } | |
float floatResult() const { return m_queryFloatResult; } | |
FloatPoint pointResult() const { return m_queryPointResult; } | |
FloatRect rectResult() const { return m_queryRectResult; } | |
bool stopProcessing() const { return m_stopProcessing; } | |
private: | |
const SVGTextContentElement* m_reference; | |
QueryMode m_mode; | |
long m_queryStartPosition; | |
long m_queryLength; | |
FloatPoint m_queryPointInput; | |
long m_queryLongResult; | |
float m_queryFloatResult; | |
FloatPoint m_queryPointResult; | |
FloatRect m_queryRectResult; | |
bool m_stopProcessing; | |
long m_atCharacter; | |
}; | |
static Vector<SVGInlineTextBox*> findInlineTextBoxInTextChunks(const SVGTextContentElement* element, const Vector<SVGTextChunk>& chunks) | |
{ | |
Vector<SVGTextChunk>::const_iterator it = chunks.begin(); | |
const Vector<SVGTextChunk>::const_iterator end = chunks.end(); | |
Vector<SVGInlineTextBox*> boxes; | |
for (; it != end; ++it) { | |
Vector<SVGInlineBoxCharacterRange>::const_iterator boxIt = it->boxes.begin(); | |
const Vector<SVGInlineBoxCharacterRange>::const_iterator boxEnd = it->boxes.end(); | |
for (; boxIt != boxEnd; ++boxIt) { | |
SVGInlineTextBox* textBox = static_cast<SVGInlineTextBox*>(boxIt->box); | |
Node* textElement = textBox->textRenderer()->parent()->node(); | |
ASSERT(textElement); | |
if (textElement == element || textElement->parent() == element) | |
boxes.append(textBox); | |
} | |
} | |
return boxes; | |
} | |
static inline SVGRootInlineBox* rootInlineBoxForTextContentElement(const SVGTextContentElement* element) | |
{ | |
RenderObject* object = element->renderer(); | |
if (!object || !object->isSVGText() || object->isText()) | |
return 0; | |
RenderBlock* svgText = toRenderBlock(object); | |
// Find root inline box | |
SVGRootInlineBox* rootBox = static_cast<SVGRootInlineBox*>(svgText->firstRootBox()); | |
if (!rootBox) { | |
// Layout is not sync yet! | |
element->document()->updateLayoutIgnorePendingStylesheets(); | |
rootBox = static_cast<SVGRootInlineBox*>(svgText->firstRootBox()); | |
} | |
ASSERT(rootBox); | |
return rootBox; | |
} | |
static inline SVGInlineTextBoxQueryWalker executeTextQuery(const SVGTextContentElement* element, SVGInlineTextBoxQueryWalker::QueryMode mode, | |
long startPosition = 0, long length = 0, FloatPoint referencePoint = FloatPoint()) | |
{ | |
SVGRootInlineBox* rootBox = rootInlineBoxForTextContentElement(element); | |
if (!rootBox) | |
return SVGInlineTextBoxQueryWalker(0, mode); | |
// Find all inline text box associated with our renderer | |
Vector<SVGInlineTextBox*> textBoxes = findInlineTextBoxInTextChunks(element, rootBox->svgTextChunks()); | |
// Walk text chunks to find chunks associated with our inline text box | |
SVGInlineTextBoxQueryWalker walkerCallback(element, mode); | |
walkerCallback.setQueryInputParameters(startPosition, length, referencePoint); | |
SVGTextChunkWalker<SVGInlineTextBoxQueryWalker> walker(&walkerCallback, &SVGInlineTextBoxQueryWalker::chunkPortionCallback); | |
Vector<SVGInlineTextBox*>::iterator it = textBoxes.begin(); | |
Vector<SVGInlineTextBox*>::iterator end = textBoxes.end(); | |
for (; it != end; ++it) { | |
rootBox->walkTextChunks(&walker, *it); | |
if (walkerCallback.stopProcessing()) | |
break; | |
} | |
return walkerCallback; | |
} | |
unsigned SVGTextContentElement::getNumberOfChars() const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::NumberOfCharacters).longResult(); | |
} | |
float SVGTextContentElement::getComputedTextLength() const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::TextLength).floatResult(); | |
} | |
float SVGTextContentElement::getSubStringLength(unsigned charnum, unsigned nchars, ExceptionCode& ec) const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
unsigned numberOfChars = getNumberOfChars(); | |
if (charnum >= numberOfChars) { | |
ec = INDEX_SIZE_ERR; | |
return 0.0f; | |
} | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::SubStringLength, charnum, nchars).floatResult(); | |
} | |
FloatPoint SVGTextContentElement::getStartPositionOfChar(unsigned charnum, ExceptionCode& ec) const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
if (charnum > getNumberOfChars()) { | |
ec = INDEX_SIZE_ERR; | |
return FloatPoint(); | |
} | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::StartPosition, charnum).pointResult(); | |
} | |
FloatPoint SVGTextContentElement::getEndPositionOfChar(unsigned charnum, ExceptionCode& ec) const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
if (charnum > getNumberOfChars()) { | |
ec = INDEX_SIZE_ERR; | |
return FloatPoint(); | |
} | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::EndPosition, charnum).pointResult(); | |
} | |
FloatRect SVGTextContentElement::getExtentOfChar(unsigned charnum, ExceptionCode& ec) const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
if (charnum > getNumberOfChars()) { | |
ec = INDEX_SIZE_ERR; | |
return FloatRect(); | |
} | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::Extent, charnum).rectResult(); | |
} | |
float SVGTextContentElement::getRotationOfChar(unsigned charnum, ExceptionCode& ec) const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
if (charnum > getNumberOfChars()) { | |
ec = INDEX_SIZE_ERR; | |
return 0.0f; | |
} | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::Rotation, charnum).floatResult(); | |
} | |
int SVGTextContentElement::getCharNumAtPosition(const FloatPoint& point) const | |
{ | |
document()->updateLayoutIgnorePendingStylesheets(); | |
return executeTextQuery(this, SVGInlineTextBoxQueryWalker::CharacterNumberAtPosition, 0.0f, 0.0f, point).longResult(); | |
} | |
void SVGTextContentElement::selectSubString(unsigned charnum, unsigned nchars, ExceptionCode& ec) const | |
{ | |
unsigned numberOfChars = getNumberOfChars(); | |
if (charnum >= numberOfChars) { | |
ec = INDEX_SIZE_ERR; | |
return; | |
} | |
if (nchars > numberOfChars - charnum) | |
nchars = numberOfChars - charnum; | |
ASSERT(document()); | |
ASSERT(document()->frame()); | |
SelectionController* controller = document()->frame()->selection(); | |
if (!controller) | |
return; | |
// Find selection start | |
VisiblePosition start(const_cast<SVGTextContentElement*>(this), 0, SEL_DEFAULT_AFFINITY); | |
for (unsigned i = 0; i < charnum; ++i) | |
start = start.next(); | |
// Find selection end | |
VisiblePosition end(start); | |
for (unsigned i = 0; i < nchars; ++i) | |
end = end.next(); | |
controller->setSelection(VisibleSelection(start, end)); | |
} | |
void SVGTextContentElement::parseMappedAttribute(MappedAttribute* attr) | |
{ | |
if (attr->name() == SVGNames::lengthAdjustAttr) { | |
if (attr->value() == "spacing") | |
setLengthAdjustBaseValue(LENGTHADJUST_SPACING); | |
else if (attr->value() == "spacingAndGlyphs") | |
setLengthAdjustBaseValue(LENGTHADJUST_SPACINGANDGLYPHS); | |
} else if (attr->name() == SVGNames::textLengthAttr) { | |
setTextLengthBaseValue(SVGLength(LengthModeOther, attr->value())); | |
if (textLengthBaseValue().value(this) < 0.0) | |
document()->accessSVGExtensions()->reportError("A negative value for text attribute <textLength> is not allowed"); | |
} else { | |
if (SVGTests::parseMappedAttribute(attr)) | |
return; | |
if (SVGLangSpace::parseMappedAttribute(attr)) { | |
if (attr->name().matches(XMLNames::spaceAttr)) { | |
DEFINE_STATIC_LOCAL(const AtomicString, preserveString, ("preserve")); | |
if (attr->value() == preserveString) | |
addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValuePre); | |
else | |
addCSSProperty(attr, CSSPropertyWhiteSpace, CSSValueNowrap); | |
} | |
return; | |
} | |
if (SVGExternalResourcesRequired::parseMappedAttribute(attr)) | |
return; | |
SVGStyledElement::parseMappedAttribute(attr); | |
} | |
} | |
void SVGTextContentElement::synchronizeProperty(const QualifiedName& attrName) | |
{ | |
SVGStyledElement::synchronizeProperty(attrName); | |
if (attrName == anyQName()) { | |
synchronizeLengthAdjust(); | |
synchronizeTextLength(); | |
synchronizeExternalResourcesRequired(); | |
return; | |
} | |
if (attrName == SVGNames::lengthAdjustAttr) | |
synchronizeLengthAdjust(); | |
else if (attrName == SVGNames::textLengthAttr) | |
synchronizeTextLength(); | |
else if (SVGExternalResourcesRequired::isKnownAttribute(attrName)) | |
synchronizeExternalResourcesRequired(); | |
} | |
bool SVGTextContentElement::isKnownAttribute(const QualifiedName& attrName) | |
{ | |
return (attrName.matches(SVGNames::lengthAdjustAttr) || | |
attrName.matches(SVGNames::textLengthAttr) || | |
SVGTests::isKnownAttribute(attrName) || | |
SVGLangSpace::isKnownAttribute(attrName) || | |
SVGExternalResourcesRequired::isKnownAttribute(attrName) || | |
SVGStyledElement::isKnownAttribute(attrName)); | |
} | |
} | |
#endif // ENABLE(SVG) |