RenderSVGInlineText.cpp [plain text]
#include "config.h"
#include "RenderSVGInlineText.h"
#include "CSSFontSelector.h"
#include "FloatConversion.h"
#include "FloatQuad.h"
#include "RenderBlock.h"
#include "RenderSVGRoot.h"
#include "RenderSVGText.h"
#include "Settings.h"
#include "SVGInlineTextBox.h"
#include "SVGRenderingContext.h"
#include "SVGRootInlineBox.h"
#include "StyleFontSizeFunctions.h"
#include "StyleResolver.h"
#include "VisiblePosition.h"
namespace WebCore {
static String applySVGWhitespaceRules(const String& string, bool preserveWhiteSpace)
{
String newString = string;
if (preserveWhiteSpace) {
newString.replace('\t', ' ');
newString.replace('\n', ' ');
newString.replace('\r', ' ');
return newString;
}
newString.replace('\n', emptyString());
newString.replace('\r', emptyString());
newString.replace('\t', ' ');
return newString;
}
RenderSVGInlineText::RenderSVGInlineText(Text& textNode, const String& string)
: RenderText(textNode, applySVGWhitespaceRules(string, false))
, m_scalingFactor(1)
, m_layoutAttributes(*this)
{
}
String RenderSVGInlineText::originalText() const
{
return textNode().data();
}
void RenderSVGInlineText::setRenderedText(const String& text)
{
RenderText::setRenderedText(text);
if (auto* textAncestor = RenderSVGText::locateRenderSVGTextAncestor(*this))
textAncestor->subtreeTextDidChange(this);
}
void RenderSVGInlineText::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderText::styleDidChange(diff, oldStyle);
updateScaledFont();
bool newPreserves = style().whiteSpace() == PRE;
bool oldPreserves = oldStyle ? oldStyle->whiteSpace() == PRE : false;
if (oldPreserves && !newPreserves) {
setText(applySVGWhitespaceRules(originalText(), false), true);
return;
}
if (!oldPreserves && newPreserves) {
setText(applySVGWhitespaceRules(originalText(), true), true);
return;
}
if (diff != StyleDifferenceLayout)
return;
if (auto* textAncestor = RenderSVGText::locateRenderSVGTextAncestor(*this))
textAncestor->subtreeStyleDidChange(this);
}
std::unique_ptr<InlineTextBox> RenderSVGInlineText::createTextBox()
{
auto box = std::make_unique<SVGInlineTextBox>(*this);
box->setHasVirtualLogicalHeight();
return WTF::move(box);
}
LayoutRect RenderSVGInlineText::localCaretRect(InlineBox* box, int caretOffset, LayoutUnit*)
{
if (!box || !box->isInlineTextBox())
return LayoutRect();
InlineTextBox* textBox = toInlineTextBox(box);
if (static_cast<unsigned>(caretOffset) < textBox->start() || static_cast<unsigned>(caretOffset) > textBox->start() + textBox->len())
return LayoutRect();
if (static_cast<unsigned>(caretOffset) < textBox->start() + textBox->len()) {
LayoutRect rect = textBox->localSelectionRect(caretOffset, caretOffset + 1);
LayoutUnit x = box->isLeftToRightDirection() ? rect.x() : rect.maxX();
return LayoutRect(x, rect.y(), caretWidth, rect.height());
}
LayoutRect rect = textBox->localSelectionRect(caretOffset - 1, caretOffset);
LayoutUnit x = box->isLeftToRightDirection() ? rect.maxX() : rect.x();
return LayoutRect(x, rect.y(), caretWidth, rect.height());
}
FloatRect RenderSVGInlineText::floatLinesBoundingBox() const
{
FloatRect boundingBox;
for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
boundingBox.unite(box->calculateBoundaries());
return boundingBox;
}
IntRect RenderSVGInlineText::linesBoundingBox() const
{
return enclosingIntRect(floatLinesBoundingBox());
}
bool RenderSVGInlineText::characterStartsNewTextChunk(int position) const
{
ASSERT(position >= 0);
ASSERT(position < static_cast<int>(textLength()));
if (!position && parent()->isSVGTextPath() && !previousSibling())
return true;
const SVGCharacterDataMap::const_iterator it = m_layoutAttributes.characterDataMap().find(static_cast<unsigned>(position + 1));
if (it == m_layoutAttributes.characterDataMap().end())
return false;
return it->value.x != SVGTextLayoutAttributes::emptyValue() || it->value.y != SVGTextLayoutAttributes::emptyValue();
}
VisiblePosition RenderSVGInlineText::positionForPoint(const LayoutPoint& point, const RenderRegion*)
{
if (!firstTextBox() || !textLength())
return createVisiblePosition(0, DOWNSTREAM);
float baseline = m_scaledFont.fontMetrics().floatAscent();
RenderBlock* containingBlock = this->containingBlock();
ASSERT(containingBlock);
FloatPoint absolutePoint(point);
absolutePoint.moveBy(containingBlock->location());
float closestDistance = std::numeric_limits<float>::max();
float closestDistancePosition = 0;
const SVGTextFragment* closestDistanceFragment = 0;
SVGInlineTextBox* closestDistanceBox = 0;
AffineTransform fragmentTransform;
for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
if (!box->isSVGInlineTextBox())
continue;
SVGInlineTextBox* textBox = toSVGInlineTextBox(box);
Vector<SVGTextFragment>& fragments = textBox->textFragments();
unsigned textFragmentsSize = fragments.size();
for (unsigned i = 0; i < textFragmentsSize; ++i) {
const SVGTextFragment& fragment = fragments.at(i);
FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
fragment.buildFragmentTransform(fragmentTransform);
if (!fragmentTransform.isIdentity())
fragmentRect = fragmentTransform.mapRect(fragmentRect);
float distance = powf(fragmentRect.x() - absolutePoint.x(), 2) +
powf(fragmentRect.y() + fragmentRect.height() / 2 - absolutePoint.y(), 2);
if (distance < closestDistance) {
closestDistance = distance;
closestDistanceBox = textBox;
closestDistanceFragment = &fragment;
closestDistancePosition = fragmentRect.x();
}
}
}
if (!closestDistanceFragment)
return createVisiblePosition(0, DOWNSTREAM);
int offset = closestDistanceBox->offsetForPositionInFragment(*closestDistanceFragment, absolutePoint.x() - closestDistancePosition, true);
return createVisiblePosition(offset + closestDistanceBox->start(), offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);
}
void RenderSVGInlineText::updateScaledFont()
{
computeNewScaledFontForStyle(*this, style(), m_scalingFactor, m_scaledFont);
}
void RenderSVGInlineText::computeNewScaledFontForStyle(const RenderObject& renderer, const RenderStyle& style, float& scalingFactor, Font& scaledFont)
{
scalingFactor = SVGRenderingContext::calculateScreenFontSizeScalingFactor(renderer);
if (scalingFactor == 1 || !scalingFactor || style.fontDescription().textRenderingMode() == GeometricPrecision) {
scalingFactor = 1;
scaledFont = style.font();
return;
}
FontDescription fontDescription(style.fontDescription());
fontDescription.setComputedSize(Style::computedFontSizeFromSpecifiedSizeForSVGInlineText(fontDescription.computedSize(), fontDescription.isAbsoluteSize(), scalingFactor, renderer.document()));
scaledFont = Font(fontDescription, 0, 0);
scaledFont.update(renderer.document().ensureStyleResolver().fontSelector());
}
}