src/third_party/WebKit/Source/core/rendering/svg/RenderSVGInlineText.cpp

   1 /*
   2  * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz>
   3  * Copyright (C) 2006 Apple Computer Inc.
   4  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
   5  * Copyright (C) 2008 Rob Buis <buis@kde.org>
   6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "config.h"
  25
  26 #include "core/rendering/svg/RenderSVGInlineText.h"
  27
  28 #include "core/css/CSSFontSelector.h"
  29 #include "core/css/FontSize.h"
  30 #include "core/dom/StyleEngine.h"
  31 #include "core/editing/VisiblePosition.h"
  32 #include "core/rendering/svg/RenderSVGText.h"
  33 #include "core/rendering/svg/SVGInlineTextBox.h"
  34 #include "core/rendering/svg/SVGRenderingContext.h"
  35
  36 namespace blink {
  37
  38 static PassRefPtr<StringImpl> applySVGWhitespaceRules(PassRefPtr<StringImpl> string, bool preserveWhiteSpace)
  39 {
  40     if (preserveWhiteSpace) {
  41         // Spec: When xml:space="preserve", the SVG user agent will do the following using a
  42         // copy of the original character data content. It will convert all newline and tab
  43         // characters into space characters. Then, it will draw all space characters, including
  44         // leading, trailing and multiple contiguous space characters.
  45         RefPtr<StringImpl> newString = string->replace('\t', ' ');
  46         newString = newString->replace('\n', ' ');
  47         newString = newString->replace('\r', ' ');
  48         return newString.release();
  49     }
  50
  51     // Spec: When xml:space="default", the SVG user agent will do the following using a
  52     // copy of the original character data content. First, it will remove all newline
  53     // characters. Then it will convert all tab characters into space characters.
  54     // Then, it will strip off all leading and trailing space characters.
  55     // Then, all contiguous space characters will be consolidated.
  56     RefPtr<StringImpl> newString = string->replace('\n', StringImpl::empty());
  57     newString = newString->replace('\r', StringImpl::empty());
  58     newString = newString->replace('\t', ' ');
  59     return newString.release();
  60 }
  61
  62 RenderSVGInlineText::RenderSVGInlineText(Node* n, PassRefPtr<StringImpl> string)
  63     : RenderText(n, applySVGWhitespaceRules(string, false))
  64     , m_scalingFactor(1)
  65     , m_layoutAttributes(this)
  66 {
  67 }
  68
  69 void RenderSVGInlineText::setTextInternal(PassRefPtr<StringImpl> text)
  70 {
  71     RenderText::setTextInternal(text);
  72     if (RenderSVGText* textRenderer = RenderSVGText::locateRenderSVGTextAncestor(this))
  73         textRenderer->subtreeTextDidChange(this);
  74 }
  75
  76 void RenderSVGInlineText::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
  77 {
  78     RenderText::styleDidChange(diff, oldStyle);
  79     updateScaledFont();
  80
  81     bool newPreserves = style() ? style()->whiteSpace() == PRE : false;
  82     bool oldPreserves = oldStyle ? oldStyle->whiteSpace() == PRE : false;
  83     if (oldPreserves != newPreserves) {
  84         setText(originalText(), true);
  85         return;
  86     }
  87
  88     if (!diff.needsFullLayout())
  89         return;
  90
  91     // The text metrics may be influenced by style changes.
  92     if (RenderSVGText* textRenderer = RenderSVGText::locateRenderSVGTextAncestor(this))
  93         textRenderer->setNeedsLayoutAndFullPaintInvalidation();
  94 }
  95
  96 InlineTextBox* RenderSVGInlineText::createTextBox(int start, unsigned short length)
  97 {
  98     InlineTextBox* box = new SVGInlineTextBox(*this, start, length);
  99     box->setHasVirtualLogicalHeight();
 100     return box;
 101 }
 102
 103 LayoutRect RenderSVGInlineText::localCaretRect(InlineBox* box, int caretOffset, LayoutUnit*)
 104 {
 105     if (!box || !box->isInlineTextBox())
 106         return LayoutRect();
 107
 108     InlineTextBox* textBox = toInlineTextBox(box);
 109     if (static_cast<unsigned>(caretOffset) < textBox->start() || static_cast<unsigned>(caretOffset) > textBox->start() + textBox->len())
 110         return LayoutRect();
 111
 112     // Use the edge of the selection rect to determine the caret rect.
 113     if (static_cast<unsigned>(caretOffset) < textBox->start() + textBox->len()) {
 114         LayoutRect rect = textBox->localSelectionRect(caretOffset, caretOffset + 1);
 115         LayoutUnit x = box->isLeftToRightDirection() ? rect.x() : rect.maxX();
 116         return LayoutRect(x, rect.y(), caretWidth, rect.height());
 117     }
 118
 119     LayoutRect rect = textBox->localSelectionRect(caretOffset - 1, caretOffset);
 120     LayoutUnit x = box->isLeftToRightDirection() ? rect.maxX() : rect.x();
 121     return LayoutRect(x, rect.y(), caretWidth, rect.height());
 122 }
 123
 124 FloatRect RenderSVGInlineText::floatLinesBoundingBox() const
 125 {
 126     FloatRect boundingBox;
 127     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
 128         boundingBox.unite(box->calculateBoundaries());
 129     return boundingBox;
 130 }
 131
 132 IntRect RenderSVGInlineText::linesBoundingBox() const
 133 {
 134     return enclosingIntRect(floatLinesBoundingBox());
 135 }
 136
 137 bool RenderSVGInlineText::characterStartsNewTextChunk(int position) const
 138 {
 139     ASSERT(position >= 0);
 140     ASSERT(position < static_cast<int>(textLength()));
 141
 142     // Each <textPath> element starts a new text chunk, regardless of any x/y values.
 143     if (!position && parent()->isSVGTextPath() && !previousSibling())
 144         return true;
 145
 146     const SVGCharacterDataMap::const_iterator it = m_layoutAttributes.characterDataMap().find(static_cast<unsigned>(position + 1));
 147     if (it == m_layoutAttributes.characterDataMap().end())
 148         return false;
 149
 150     return it->value.x != SVGTextLayoutAttributes::emptyValue() || it->value.y != SVGTextLayoutAttributes::emptyValue();
 151 }
 152
 153 PositionWithAffinity RenderSVGInlineText::positionForPoint(const LayoutPoint& point)
 154 {
 155     if (!firstTextBox() || !textLength())
 156         return createPositionWithAffinity(0, DOWNSTREAM);
 157
 158     float baseline = m_scaledFont.fontMetrics().floatAscent();
 159
 160     RenderBlock* containingBlock = this->containingBlock();
 161     ASSERT(containingBlock);
 162
 163     // Map local point to absolute point, as the character origins stored in the text fragments use absolute coordinates.
 164     FloatPoint absolutePoint(point);
 165     absolutePoint.moveBy(containingBlock->location());
 166
 167     float closestDistance = std::numeric_limits<float>::max();
 168     float closestDistancePosition = 0;
 169     const SVGTextFragment* closestDistanceFragment = 0;
 170     SVGInlineTextBox* closestDistanceBox = 0;
 171
 172     AffineTransform fragmentTransform;
 173     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
 174         if (!box->isSVGInlineTextBox())
 175             continue;
 176
 177         SVGInlineTextBox* textBox = toSVGInlineTextBox(box);
 178         Vector<SVGTextFragment>& fragments = textBox->textFragments();
 179
 180         unsigned textFragmentsSize = fragments.size();
 181         for (unsigned i = 0; i < textFragmentsSize; ++i) {
 182             const SVGTextFragment& fragment = fragments.at(i);
 183             FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
 184             fragment.buildFragmentTransform(fragmentTransform);
 185             fragmentRect = fragmentTransform.mapRect(fragmentRect);
 186
 187             float distance = powf(fragmentRect.x() - absolutePoint.x(), 2) +
 188                              powf(fragmentRect.y() + fragmentRect.height() / 2 - absolutePoint.y(), 2);
 189
 190             if (distance < closestDistance) {
 191                 closestDistance = distance;
 192                 closestDistanceBox = textBox;
 193                 closestDistanceFragment = &fragment;
 194                 closestDistancePosition = fragmentRect.x();
 195             }
 196         }
 197     }
 198
 199     if (!closestDistanceFragment)
 200         return createPositionWithAffinity(0, DOWNSTREAM);
 201
 202     int offset = closestDistanceBox->offsetForPositionInFragment(*closestDistanceFragment, absolutePoint.x() - closestDistancePosition, true);
 203     return createPositionWithAffinity(offset + closestDistanceBox->start(), offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);
 204 }
 205
 206 void RenderSVGInlineText::updateScaledFont()
 207 {
 208     computeNewScaledFontForStyle(this, style(), m_scalingFactor, m_scaledFont);
 209 }
 210
 211 void RenderSVGInlineText::computeNewScaledFontForStyle(RenderObject* renderer, const RenderStyle* style, float& scalingFactor, Font& scaledFont)
 212 {
 213     ASSERT(style);
 214     ASSERT(renderer);
 215
 216     // Alter font-size to the right on-screen value to avoid scaling the glyphs themselves, except when GeometricPrecision is specified.
 217     scalingFactor = SVGRenderingContext::calculateScreenFontSizeScalingFactor(renderer);
 218     if (style->effectiveZoom() == 1 && (scalingFactor == 1 || !scalingFactor)) {
 219         scalingFactor = 1;
 220         scaledFont = style->font();
 221         return;
 222     }
 223
 224     if (style->fontDescription().textRendering() == GeometricPrecision)
 225         scalingFactor = 1;
 226
 227     FontDescription fontDescription(style->fontDescription());
 228
 229     Document& document = renderer->document();
 230     // FIXME: We need to better handle the case when we compute very small fonts below (below 1pt).
 231     fontDescription.setComputedSize(FontSize::getComputedSizeFromSpecifiedSize(&document, scalingFactor, fontDescription.isAbsoluteSize(), fontDescription.specifiedSize(), DoNotUseSmartMinimumForFontSize));
 232
 233     scaledFont = Font(fontDescription);
 234     scaledFont.update(document.styleEngine()->fontSelector());
 235 }
 236
 237 LayoutRect RenderSVGInlineText::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 238 {
 239     // FIXME: The following works because RenderSVGBlock has forced slow rect mapping of the paintInvalidationState.
 240     // Should let this really work with paintInvalidationState's fast mapping and remove the assert.
 241     ASSERT(!paintInvalidationState || !paintInvalidationState->canMapToContainer(paintInvalidationContainer));
 242     return parent()->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer, paintInvalidationState);
 243 }
 244
 245 PassRefPtr<StringImpl> RenderSVGInlineText::originalText() const
 246 {
 247     RefPtr<StringImpl> result = RenderText::originalText();
 248     if (!result)
 249         return nullptr;
 250     return applySVGWhitespaceRules(result, style() && style()->whiteSpace() == PRE);
 251 }
 252
 253 }