Unreviewed, rolling out r116498.
[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 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 #if ENABLE(SVG)
27 #include "RenderSVGInlineText.h"
28
29 #include "CSSFontSelector.h"
30 #include "FloatConversion.h"
31 #include "FloatQuad.h"
32 #include "RenderBlock.h"
33 #include "RenderSVGRoot.h"
34 #include "RenderSVGText.h"
35 #include "Settings.h"
36 #include "SVGInlineTextBox.h"
37 #include "SVGRenderingContext.h"
38 #include "SVGRootInlineBox.h"
39 #include "StyleResolver.h"
40 #include "VisiblePosition.h"
41
42 namespace WebCore {
43
44 static PassRefPtr<StringImpl> applySVGWhitespaceRules(PassRefPtr<StringImpl> string, bool preserveWhiteSpace)
45 {
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         RefPtr<StringImpl> newString = string->replace('\t', ' ');
52         newString = newString->replace('\n', ' ');
53         newString = newString->replace('\r', ' ');
54         return newString.release();
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     RefPtr<StringImpl> newString = string->replace('\n', StringImpl::empty());
63     newString = newString->replace('\r', StringImpl::empty());
64     newString = newString->replace('\t', ' ');
65     return newString.release();
66 }
67
68 RenderSVGInlineText::RenderSVGInlineText(Node* n, PassRefPtr<StringImpl> string)
69     : RenderText(n, applySVGWhitespaceRules(string, false))
70     , m_scalingFactor(1)
71     , m_layoutAttributes(this)
72 {
73 }
74
75 void RenderSVGInlineText::willBeDestroyed()
76 {
77     RenderSVGText* textRenderer = RenderSVGText::locateRenderSVGTextAncestor(this);
78     if (!textRenderer) {
79         RenderText::willBeDestroyed();
80         return;
81     }
82
83     Vector<SVGTextLayoutAttributes*> affectedAttributes;
84     textRenderer->layoutAttributesWillBeDestroyed(this, affectedAttributes);
85
86     RenderText::willBeDestroyed();
87     if (affectedAttributes.isEmpty())
88         return;
89
90     if (!documentBeingDestroyed())
91         textRenderer->rebuildLayoutAttributes(affectedAttributes);
92 }
93
94 void RenderSVGInlineText::setTextInternal(PassRefPtr<StringImpl> text)
95 {
96     RenderText::setTextInternal(text);
97
98     // When the underlying text content changes, call both textDOMChanged() & layoutAttributesChanged()
99     // The former will clear the SVGTextPositioningElement cache, which depends on the textLength() of
100     // the RenderSVGInlineText objects, and thus needs to be rebuild. The latter will assure that the
101     // SVGTextLayoutAttributes associated with the RenderSVGInlineText will be updated.
102     if (RenderSVGText* textRenderer = RenderSVGText::locateRenderSVGTextAncestor(this)) {
103         textRenderer->invalidateTextPositioningElements();
104         textRenderer->layoutAttributesChanged(this);
105     }
106 }
107
108 void RenderSVGInlineText::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
109 {
110     RenderText::styleDidChange(diff, oldStyle);
111     updateScaledFont();
112
113     bool newPreserves = style() ? style()->whiteSpace() == PRE : false;
114     bool oldPreserves = oldStyle ? oldStyle->whiteSpace() == PRE : false;
115     if (oldPreserves && !newPreserves) {
116         setText(applySVGWhitespaceRules(originalText(), false), true);
117         return;
118     }
119
120     if (!oldPreserves && newPreserves) {
121         setText(applySVGWhitespaceRules(originalText(), true), true);
122         return;
123     }
124
125     if (diff != StyleDifferenceLayout)
126         return;
127
128     // The text metrics may be influenced by style changes.
129     if (RenderSVGText* textRenderer = RenderSVGText::locateRenderSVGTextAncestor(this))
130         textRenderer->layoutAttributesChanged(this);
131 }
132
133 InlineTextBox* RenderSVGInlineText::createTextBox()
134 {
135     InlineTextBox* box = new (renderArena()) SVGInlineTextBox(this);
136     box->setHasVirtualLogicalHeight();
137     return box;
138 }
139
140 LayoutRect RenderSVGInlineText::localCaretRect(InlineBox* box, int caretOffset, LayoutUnit*)
141 {
142     if (!box || !box->isInlineTextBox())
143         return LayoutRect();
144
145     InlineTextBox* textBox = static_cast<InlineTextBox*>(box);
146     if (static_cast<unsigned>(caretOffset) < textBox->start() || static_cast<unsigned>(caretOffset) > textBox->start() + textBox->len())
147         return LayoutRect();
148
149     // Use the edge of the selection rect to determine the caret rect.
150     if (static_cast<unsigned>(caretOffset) < textBox->start() + textBox->len()) {
151         LayoutRect rect = textBox->localSelectionRect(caretOffset, caretOffset + 1);
152         LayoutUnit x = box->isLeftToRightDirection() ? rect.x() : rect.maxX();
153         return LayoutRect(x, rect.y(), caretWidth, rect.height());
154     }
155
156     LayoutRect rect = textBox->localSelectionRect(caretOffset - 1, caretOffset);
157     LayoutUnit x = box->isLeftToRightDirection() ? rect.maxX() : rect.x();
158     return LayoutRect(x, rect.y(), caretWidth, rect.height());
159 }
160
161 FloatRect RenderSVGInlineText::floatLinesBoundingBox() const
162 {
163     FloatRect boundingBox;
164     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
165         boundingBox.unite(box->calculateBoundaries());
166     return boundingBox;
167 }
168
169 IntRect RenderSVGInlineText::linesBoundingBox() const
170 {
171     return enclosingIntRect(floatLinesBoundingBox());
172 }
173
174 bool RenderSVGInlineText::characterStartsNewTextChunk(int position) const
175 {
176     ASSERT(position >= 0);
177     ASSERT(position < static_cast<int>(textLength()));
178
179     // Each <textPath> element starts a new text chunk, regardless of any x/y values.
180     if (!position && parent()->isSVGTextPath() && !previousSibling())
181         return true;
182
183     const SVGCharacterDataMap::const_iterator it = m_layoutAttributes.characterDataMap().find(static_cast<unsigned>(position + 1));
184     if (it == m_layoutAttributes.characterDataMap().end())
185         return false;
186
187     return it->second.x != SVGTextLayoutAttributes::emptyValue() || it->second.y != SVGTextLayoutAttributes::emptyValue();
188 }
189
190 VisiblePosition RenderSVGInlineText::positionForPoint(const LayoutPoint& point)
191 {
192     if (!firstTextBox() || !textLength())
193         return createVisiblePosition(0, DOWNSTREAM);
194
195     float baseline = m_scaledFont.fontMetrics().floatAscent();
196
197     RenderBlock* containingBlock = this->containingBlock();
198     ASSERT(containingBlock);
199
200     // Map local point to absolute point, as the character origins stored in the text fragments use absolute coordinates.
201     FloatPoint absolutePoint(point);
202     absolutePoint.moveBy(containingBlock->location());
203
204     float closestDistance = std::numeric_limits<float>::max();
205     float closestDistancePosition = 0;
206     const SVGTextFragment* closestDistanceFragment = 0;
207     SVGInlineTextBox* closestDistanceBox = 0;
208
209     AffineTransform fragmentTransform;
210     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
211         if (!box->isSVGInlineTextBox())
212             continue;
213
214         SVGInlineTextBox* textBox = static_cast<SVGInlineTextBox*>(box);
215         Vector<SVGTextFragment>& fragments = textBox->textFragments();
216
217         unsigned textFragmentsSize = fragments.size();
218         for (unsigned i = 0; i < textFragmentsSize; ++i) {
219             const SVGTextFragment& fragment = fragments.at(i);
220             FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
221             fragment.buildFragmentTransform(fragmentTransform);
222             if (!fragmentTransform.isIdentity())
223                 fragmentRect = fragmentTransform.mapRect(fragmentRect);
224
225             float distance = powf(fragmentRect.x() - absolutePoint.x(), 2) +
226                              powf(fragmentRect.y() + fragmentRect.height() / 2 - absolutePoint.y(), 2);
227
228             if (distance < closestDistance) {
229                 closestDistance = distance;
230                 closestDistanceBox = textBox;
231                 closestDistanceFragment = &fragment;
232                 closestDistancePosition = fragmentRect.x();
233             }
234         }
235     }
236
237     if (!closestDistanceFragment)
238         return createVisiblePosition(0, DOWNSTREAM);
239
240     int offset = closestDistanceBox->offsetForPositionInFragment(*closestDistanceFragment, absolutePoint.x() - closestDistancePosition, true);
241     return createVisiblePosition(offset + closestDistanceBox->start(), offset > 0 ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM);
242 }
243
244 void RenderSVGInlineText::updateScaledFont()
245 {
246     computeNewScaledFontForStyle(this, style(), m_scalingFactor, m_scaledFont);
247 }
248
249 void RenderSVGInlineText::computeNewScaledFontForStyle(RenderObject* renderer, const RenderStyle* style, float& scalingFactor, Font& scaledFont)
250 {
251     ASSERT(style);
252     ASSERT(renderer);
253
254     Document* document = renderer->document();
255     ASSERT(document);
256     
257     StyleResolver* styleResolver = document->styleResolver();
258     ASSERT(styleResolver);
259
260     // Alter font-size to the right on-screen value to avoid scaling the glyphs themselves, except when GeometricPrecision is specified
261     AffineTransform ctm;
262     SVGRenderingContext::calculateTransformationToOutermostSVGCoordinateSystem(renderer, ctm);
263     scalingFactor = narrowPrecisionToFloat(sqrt((pow(ctm.xScale(), 2) + pow(ctm.yScale(), 2)) / 2));
264     if (scalingFactor == 1 || !scalingFactor || style->fontDescription().textRenderingMode() == GeometricPrecision) {
265         scalingFactor = 1;
266         scaledFont = style->font();
267         return;
268     }
269
270     FontDescription fontDescription(style->fontDescription());
271
272     // FIXME: We need to better handle the case when we compute very small fonts below (below 1pt).
273     fontDescription.setComputedSize(StyleResolver::getComputedSizeFromSpecifiedSize(document, scalingFactor, fontDescription.isAbsoluteSize(), fontDescription.computedSize(), DoNotUseSmartMinimumForFontSize));
274
275     scaledFont = Font(fontDescription, 0, 0);
276     scaledFont.update(styleResolver->fontSelector());
277 }
278
279 }
280
281 #endif // ENABLE(SVG)