Add WTF::move()
[WebKit-https.git] / Source / WebCore / rendering / svg / RenderSVGInlineText.cpp
1 /*
2  * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz>
3  * Copyright (C) 2006 Apple 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 #include "RenderSVGInlineText.h"
26
27 #include "CSSFontSelector.h"
28 #include "FloatConversion.h"
29 #include "FloatQuad.h"
30 #include "RenderBlock.h"
31 #include "RenderSVGRoot.h"
32 #include "RenderSVGText.h"
33 #include "Settings.h"
34 #include "SVGInlineTextBox.h"
35 #include "SVGRenderingContext.h"
36 #include "SVGRootInlineBox.h"
37 #include "StyleFontSizeFunctions.h"
38 #include "StyleResolver.h"
39 #include "VisiblePosition.h"
40
41 namespace WebCore {
42
43 static String applySVGWhitespaceRules(const String& string, bool preserveWhiteSpace)
44 {
45     String newString = string;
46     if (preserveWhiteSpace) {
47         // Spec: When xml:space="preserve", the SVG user agent will do the following using a
48         // copy of the original character data content. It will convert all newline and tab
49         // characters into space characters. Then, it will draw all space characters, including
50         // leading, trailing and multiple contiguous space characters.
51         newString.replace('\t', ' ');
52         newString.replace('\n', ' ');
53         newString.replace('\r', ' ');
54         return newString;
55     }
56
57     // Spec: When xml:space="default", the SVG user agent will do the following using a
58     // copy of the original character data content. First, it will remove all newline
59     // characters. Then it will convert all tab characters into space characters.
60     // Then, it will strip off all leading and trailing space characters.
61     // Then, all contiguous space characters will be consolidated.
62     newString.replace('\n', emptyString());
63     newString.replace('\r', emptyString());
64     newString.replace('\t', ' ');
65     return newString;
66 }
67
68 RenderSVGInlineText::RenderSVGInlineText(Text& textNode, const String& string)
69     : RenderText(textNode, applySVGWhitespaceRules(string, false))
70     , m_scalingFactor(1)
71     , m_layoutAttributes(*this)
72 {
73 }
74
75 String RenderSVGInlineText::originalText() const
76 {
77     return textNode().data();
78 }
79
80 void RenderSVGInlineText::setRenderedText(const String& text)
81 {
82     RenderText::setRenderedText(text);
83     if (auto* textAncestor = RenderSVGText::locateRenderSVGTextAncestor(*this))
84         textAncestor->subtreeTextDidChange(this);
85 }
86
87 void RenderSVGInlineText::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
88 {
89     RenderText::styleDidChange(diff, oldStyle);
90     updateScaledFont();
91
92     bool newPreserves = style().whiteSpace() == PRE;
93     bool oldPreserves = oldStyle ? oldStyle->whiteSpace() == PRE : false;
94     if (oldPreserves && !newPreserves) {
95         setText(applySVGWhitespaceRules(originalText(), false), true);
96         return;
97     }
98
99     if (!oldPreserves && newPreserves) {
100         setText(applySVGWhitespaceRules(originalText(), true), true);
101         return;
102     }
103
104     if (diff != StyleDifferenceLayout)
105         return;
106
107     // The text metrics may be influenced by style changes.
108     if (auto* textAncestor = RenderSVGText::locateRenderSVGTextAncestor(*this))
109         textAncestor->subtreeStyleDidChange(this);
110 }
111
112 std::unique_ptr<InlineTextBox> RenderSVGInlineText::createTextBox()
113 {
114     auto box = std::make_unique<SVGInlineTextBox>(*this);
115     box->setHasVirtualLogicalHeight();
116     return WTF::move(box);
117 }
118
119 LayoutRect RenderSVGInlineText::localCaretRect(InlineBox* box, int caretOffset, LayoutUnit*)
120 {
121     if (!box || !box->isInlineTextBox())
122         return LayoutRect();
123
124     InlineTextBox* textBox = toInlineTextBox(box);
125     if (static_cast<unsigned>(caretOffset) < textBox->start() || static_cast<unsigned>(caretOffset) > textBox->start() + textBox->len())
126         return LayoutRect();
127
128     // Use the edge of the selection rect to determine the caret rect.
129     if (static_cast<unsigned>(caretOffset) < textBox->start() + textBox->len()) {
130         LayoutRect rect = textBox->localSelectionRect(caretOffset, caretOffset + 1);
131         LayoutUnit x = box->isLeftToRightDirection() ? rect.x() : rect.maxX();
132         return LayoutRect(x, rect.y(), caretWidth, rect.height());
133     }
134
135     LayoutRect rect = textBox->localSelectionRect(caretOffset - 1, caretOffset);
136     LayoutUnit x = box->isLeftToRightDirection() ? rect.maxX() : rect.x();
137     return LayoutRect(x, rect.y(), caretWidth, rect.height());
138 }
139
140 FloatRect RenderSVGInlineText::floatLinesBoundingBox() const
141 {
142     FloatRect boundingBox;
143     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
144         boundingBox.unite(box->calculateBoundaries());
145     return boundingBox;
146 }
147
148 IntRect RenderSVGInlineText::linesBoundingBox() const
149 {
150     return enclosingIntRect(floatLinesBoundingBox());
151 }
152
153 bool RenderSVGInlineText::characterStartsNewTextChunk(int position) const
154 {
155     ASSERT(position >= 0);
156     ASSERT(position < static_cast<int>(textLength()));
157
158     // Each <textPath> element starts a new text chunk, regardless of any x/y values.
159     if (!position && parent()->isSVGTextPath() && !previousSibling())
160         return true;
161
162     const SVGCharacterDataMap::const_iterator it = m_layoutAttributes.characterDataMap().find(static_cast<unsigned>(position + 1));
163     if (it == m_layoutAttributes.characterDataMap().end())
164         return false;
165
166     return it->value.x != SVGTextLayoutAttributes::emptyValue() || it->value.y != SVGTextLayoutAttributes::emptyValue();
167 }
168
169 VisiblePosition RenderSVGInlineText::positionForPoint(const LayoutPoint& point, const RenderRegion*)
170 {
171     if (!firstTextBox() || !textLength())
172         return createVisiblePosition(0, DOWNSTREAM);
173
174     float baseline = m_scaledFont.fontMetrics().floatAscent();
175
176     RenderBlock* containingBlock = this->containingBlock();
177     ASSERT(containingBlock);
178
179     // Map local point to absolute point, as the character origins stored in the text fragments use absolute coordinates.
180     FloatPoint absolutePoint(point);
181     absolutePoint.moveBy(containingBlock->location());
182
183     float closestDistance = std::numeric_limits<float>::max();
184     float closestDistancePosition = 0;
185     const SVGTextFragment* closestDistanceFragment = 0;
186     SVGInlineTextBox* closestDistanceBox = 0;
187
188     AffineTransform fragmentTransform;
189     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
190         if (!box->isSVGInlineTextBox())
191             continue;
192
193         SVGInlineTextBox* textBox = toSVGInlineTextBox(box);
194         Vector<SVGTextFragment>& fragments = textBox->textFragments();
195
196         unsigned textFragmentsSize = fragments.size();
197         for (unsigned i = 0; i < textFragmentsSize; ++i) {
198             const SVGTextFragment& fragment = fragments.at(i);
199             FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
200             fragment.buildFragmentTransform(fragmentTransform);
201             if (!fragmentTransform.isIdentity())
202                 fragmentRect = fragmentTransform.mapRect(fragmentRect);
203
204             float distance = powf(fragmentRect.x() - absolutePoint.x(), 2) +
205                              powf(fragmentRect.y() + fragmentRect.height() / 2 - absolutePoint.y(), 2);
206
207             if (distance < closestDistance) {
208                 closestDistance = distance;
209                 closestDistanceBox = textBox;
210                 closestDistanceFragment = &fragment;
211                 closestDistancePosition = fragmentRect.x();
212             }
213         }
214     }
215
216     if (!closestDistanceFragment)
217         return createVisiblePosition(0, DOWNSTREAM);
218
219     int offset = closestDistanceBox->offsetForPositionInFragment(*closestDistanceFragment, absolutePoint.x() - closestDistancePosition, true);
220     return createVisiblePosition(offset + closestDistanceBox->start(), offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);
221 }
222
223 void RenderSVGInlineText::updateScaledFont()
224 {
225     computeNewScaledFontForStyle(*this, style(), m_scalingFactor, m_scaledFont);
226 }
227
228 void RenderSVGInlineText::computeNewScaledFontForStyle(const RenderObject& renderer, const RenderStyle& style, float& scalingFactor, Font& scaledFont)
229 {
230     // Alter font-size to the right on-screen value to avoid scaling the glyphs themselves, except when GeometricPrecision is specified
231     scalingFactor = SVGRenderingContext::calculateScreenFontSizeScalingFactor(renderer);
232     if (scalingFactor == 1 || !scalingFactor || style.fontDescription().textRenderingMode() == GeometricPrecision) {
233         scalingFactor = 1;
234         scaledFont = style.font();
235         return;
236     }
237
238     FontDescription fontDescription(style.fontDescription());
239
240     // FIXME: We need to better handle the case when we compute very small fonts below (below 1pt).
241     fontDescription.setComputedSize(Style::computedFontSizeFromSpecifiedSizeForSVGInlineText(fontDescription.computedSize(), fontDescription.isAbsoluteSize(), scalingFactor, renderer.document()));
242
243     scaledFont = Font(fontDescription, 0, 0);
244     scaledFont.update(renderer.document().ensureStyleResolver().fontSelector());
245 }
246
247 }