1 /*
2 * Copyright (C) 2006 Apple Computer, Inc.
3 * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
4 * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz>
5 * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
6 * Copyright (C) 2008 Rob Buis <buis@kde.org>
7 * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
8 * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
9 * Copyright (C) 2012 Google Inc.
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
20 *
21 * You should have received a copy of the GNU Library General Public License
22 * along with this library; see the file COPYING.LIB. If not, write to
23 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 * Boston, MA 02110-1301, USA.
25 */
26
27 #include "config.h"
28
29 #include "core/rendering/svg/RenderSVGText.h"
30
31 #include "core/editing/PositionWithAffinity.h"
32 #include "core/paint/SVGTextPainter.h"
33 #include "core/rendering/HitTestRequest.h"
34 #include "core/rendering/HitTestResult.h"
35 #include "core/rendering/PaintInfo.h"
36 #include "core/rendering/PointerEventsHitRules.h"
37 #include "core/rendering/style/ShadowList.h"
38 #include "core/rendering/svg/RenderSVGInline.h"
39 #include "core/rendering/svg/RenderSVGInlineText.h"
40 #include "core/rendering/svg/RenderSVGResource.h"
41 #include "core/rendering/svg/RenderSVGRoot.h"
42 #include "core/rendering/svg/SVGRenderSupport.h"
43 #include "core/rendering/svg/SVGResourcesCache.h"
44 #include "core/rendering/svg/SVGRootInlineBox.h"
45 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
46 #include "core/svg/SVGLengthList.h"
47 #include "core/svg/SVGTextElement.h"
48 #include "core/svg/SVGTransformList.h"
49 #include "core/svg/SVGURIReference.h"
50 #include "platform/FloatConversion.h"
51 #include "platform/fonts/FontCache.h"
52 #include "platform/fonts/SimpleFontData.h"
53 #include "platform/geometry/FloatQuad.h"
54 #include "platform/geometry/TransformState.h"
55
56 namespace blink {
57
RenderSVGText(SVGTextElement * node)58 RenderSVGText::RenderSVGText(SVGTextElement* node)
59 : RenderSVGBlock(node)
60 , m_needsReordering(false)
61 , m_needsPositioningValuesUpdate(false)
62 , m_needsTransformUpdate(true)
63 , m_needsTextMetricsUpdate(false)
64 {
65 }
66
~RenderSVGText()67 RenderSVGText::~RenderSVGText()
68 {
69 ASSERT(m_layoutAttributes.isEmpty());
70 }
71
isChildAllowed(RenderObject * child,RenderStyle *) const72 bool RenderSVGText::isChildAllowed(RenderObject* child, RenderStyle*) const
73 {
74 return child->isSVGInline() || (child->isText() && SVGRenderSupport::isRenderableTextNode(child));
75 }
76
locateRenderSVGTextAncestor(RenderObject * start)77 RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(RenderObject* start)
78 {
79 ASSERT(start);
80 while (start && !start->isSVGText())
81 start = start->parent();
82 if (!start || !start->isSVGText())
83 return 0;
84 return toRenderSVGText(start);
85 }
86
locateRenderSVGTextAncestor(const RenderObject * start)87 const RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(const RenderObject* start)
88 {
89 ASSERT(start);
90 while (start && !start->isSVGText())
91 start = start->parent();
92 if (!start || !start->isSVGText())
93 return 0;
94 return toRenderSVGText(start);
95 }
96
mapRectToPaintInvalidationBacking(const RenderLayerModelObject * paintInvalidationContainer,LayoutRect & rect,const PaintInvalidationState * paintInvalidationState) const97 void RenderSVGText::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
98 {
99 FloatRect paintInvalidationRect = rect;
100 paintInvalidationRect.inflate(style()->outlineWidth());
101 computeFloatRectForPaintInvalidation(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
102 rect = enclosingLayoutRect(paintInvalidationRect);
103 }
104
collectLayoutAttributes(RenderObject * text,Vector<SVGTextLayoutAttributes * > & attributes)105 static inline void collectLayoutAttributes(RenderObject* text, Vector<SVGTextLayoutAttributes*>& attributes)
106 {
107 for (RenderObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
108 if (descendant->isSVGInlineText())
109 attributes.append(toRenderSVGInlineText(descendant)->layoutAttributes());
110 }
111 }
112
findPreviousAndNextAttributes(RenderSVGText * root,RenderSVGInlineText * locateElement,SVGTextLayoutAttributes * & previous,SVGTextLayoutAttributes * & next)113 static inline bool findPreviousAndNextAttributes(RenderSVGText* root, RenderSVGInlineText* locateElement, SVGTextLayoutAttributes*& previous, SVGTextLayoutAttributes*& next)
114 {
115 ASSERT(root);
116 ASSERT(locateElement);
117 bool stopAfterNext = false;
118 RenderObject* current = root->firstChild();
119 while (current) {
120 if (current->isSVGInlineText()) {
121 RenderSVGInlineText* text = toRenderSVGInlineText(current);
122 if (locateElement != text) {
123 if (stopAfterNext) {
124 next = text->layoutAttributes();
125 return true;
126 }
127
128 previous = text->layoutAttributes();
129 } else {
130 stopAfterNext = true;
131 }
132 } else if (current->isSVGInline()) {
133 // Descend into text content (if possible).
134 if (RenderObject* child = toRenderSVGInline(current)->firstChild()) {
135 current = child;
136 continue;
137 }
138 }
139
140 current = current->nextInPreOrderAfterChildren(root);
141 }
142 return false;
143 }
144
shouldHandleSubtreeMutations() const145 inline bool RenderSVGText::shouldHandleSubtreeMutations() const
146 {
147 if (beingDestroyed() || !everHadLayout()) {
148 ASSERT(m_layoutAttributes.isEmpty());
149 ASSERT(!m_layoutAttributesBuilder.numberOfTextPositioningElements());
150 return false;
151 }
152 return true;
153 }
154
subtreeChildWasAdded(RenderObject * child)155 void RenderSVGText::subtreeChildWasAdded(RenderObject* child)
156 {
157 ASSERT(child);
158 if (!shouldHandleSubtreeMutations() || documentBeingDestroyed())
159 return;
160
161 // Always protect the cache before clearing text positioning elements when the cache will subsequently be rebuilt.
162 FontCachePurgePreventer fontCachePurgePreventer;
163
164 // The positioning elements cache doesn't include the new 'child' yet. Clear the
165 // cache, as the next buildLayoutAttributesForTextRenderer() call rebuilds it.
166 m_layoutAttributesBuilder.clearTextPositioningElements();
167
168 if (!child->isSVGInlineText() && !child->isSVGInline())
169 return;
170
171 // Detect changes in layout attributes and only measure those text parts that have changed!
172 Vector<SVGTextLayoutAttributes*> newLayoutAttributes;
173 collectLayoutAttributes(this, newLayoutAttributes);
174 if (newLayoutAttributes.isEmpty()) {
175 ASSERT(m_layoutAttributes.isEmpty());
176 return;
177 }
178
179 // Compare m_layoutAttributes with newLayoutAttributes to figure out which attribute got added.
180 size_t size = newLayoutAttributes.size();
181 SVGTextLayoutAttributes* attributes = 0;
182 for (size_t i = 0; i < size; ++i) {
183 attributes = newLayoutAttributes[i];
184 if (m_layoutAttributes.find(attributes) == kNotFound) {
185 // Every time this is invoked, there's only a single new entry in the newLayoutAttributes list, compared to the old in m_layoutAttributes.
186 SVGTextLayoutAttributes* previous = 0;
187 SVGTextLayoutAttributes* next = 0;
188 ASSERT_UNUSED(child, attributes->context() == child);
189 findPreviousAndNextAttributes(this, attributes->context(), previous, next);
190
191 if (previous)
192 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(previous->context());
193 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(attributes->context());
194 if (next)
195 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(next->context());
196 break;
197 }
198 }
199
200 #if ENABLE(ASSERT)
201 // Verify that m_layoutAttributes only differs by a maximum of one entry.
202 for (size_t i = 0; i < size; ++i)
203 ASSERT(m_layoutAttributes.find(newLayoutAttributes[i]) != kNotFound || newLayoutAttributes[i] == attributes);
204 #endif
205
206 m_layoutAttributes = newLayoutAttributes;
207 }
208
checkLayoutAttributesConsistency(RenderSVGText * text,Vector<SVGTextLayoutAttributes * > & expectedLayoutAttributes)209 static inline void checkLayoutAttributesConsistency(RenderSVGText* text, Vector<SVGTextLayoutAttributes*>& expectedLayoutAttributes)
210 {
211 #if ENABLE(ASSERT)
212 Vector<SVGTextLayoutAttributes*> newLayoutAttributes;
213 collectLayoutAttributes(text, newLayoutAttributes);
214 ASSERT(newLayoutAttributes == expectedLayoutAttributes);
215 #endif
216 }
217
willBeDestroyed()218 void RenderSVGText::willBeDestroyed()
219 {
220 m_layoutAttributes.clear();
221 m_layoutAttributesBuilder.clearTextPositioningElements();
222
223 RenderSVGBlock::willBeDestroyed();
224 }
225
subtreeChildWillBeRemoved(RenderObject * child,Vector<SVGTextLayoutAttributes *,2> & affectedAttributes)226 void RenderSVGText::subtreeChildWillBeRemoved(RenderObject* child, Vector<SVGTextLayoutAttributes*, 2>& affectedAttributes)
227 {
228 ASSERT(child);
229 if (!shouldHandleSubtreeMutations())
230 return;
231
232 checkLayoutAttributesConsistency(this, m_layoutAttributes);
233
234 // The positioning elements cache depends on the size of each text renderer in the
235 // subtree. If this changes, clear the cache. It's going to be rebuilt below.
236 m_layoutAttributesBuilder.clearTextPositioningElements();
237 if (m_layoutAttributes.isEmpty() || !child->isSVGInlineText())
238 return;
239
240 // This logic requires that the 'text' child is still inserted in the tree.
241 RenderSVGInlineText* text = toRenderSVGInlineText(child);
242 SVGTextLayoutAttributes* previous = 0;
243 SVGTextLayoutAttributes* next = 0;
244 if (!documentBeingDestroyed())
245 findPreviousAndNextAttributes(this, text, previous, next);
246
247 if (previous)
248 affectedAttributes.append(previous);
249 if (next)
250 affectedAttributes.append(next);
251
252 size_t position = m_layoutAttributes.find(text->layoutAttributes());
253 ASSERT(position != kNotFound);
254 m_layoutAttributes.remove(position);
255 }
256
subtreeChildWasRemoved(const Vector<SVGTextLayoutAttributes *,2> & affectedAttributes)257 void RenderSVGText::subtreeChildWasRemoved(const Vector<SVGTextLayoutAttributes*, 2>& affectedAttributes)
258 {
259 if (!shouldHandleSubtreeMutations() || documentBeingDestroyed()) {
260 ASSERT(affectedAttributes.isEmpty());
261 return;
262 }
263
264 // This is called immediately after subtreeChildWillBeDestroyed, once the RenderSVGInlineText::willBeDestroyed() method
265 // passes on to the base class, which removes us from the render tree. At this point we can update the layout attributes.
266 unsigned size = affectedAttributes.size();
267 for (unsigned i = 0; i < size; ++i)
268 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(affectedAttributes[i]->context());
269 }
270
subtreeStyleDidChange()271 void RenderSVGText::subtreeStyleDidChange()
272 {
273 if (!shouldHandleSubtreeMutations() || documentBeingDestroyed())
274 return;
275
276 checkLayoutAttributesConsistency(this, m_layoutAttributes);
277
278 // Only update the metrics cache, but not the text positioning element cache
279 // nor the layout attributes cached in the leaf #text renderers.
280 FontCachePurgePreventer fontCachePurgePreventer;
281 for (RenderObject* descendant = firstChild(); descendant; descendant = descendant->nextInPreOrder(this)) {
282 if (descendant->isSVGInlineText())
283 m_layoutAttributesBuilder.rebuildMetricsForTextRenderer(toRenderSVGInlineText(descendant));
284 }
285 }
286
subtreeTextDidChange(RenderSVGInlineText * text)287 void RenderSVGText::subtreeTextDidChange(RenderSVGInlineText* text)
288 {
289 ASSERT(text);
290 ASSERT(!beingDestroyed());
291 if (!everHadLayout()) {
292 ASSERT(m_layoutAttributes.isEmpty());
293 ASSERT(!m_layoutAttributesBuilder.numberOfTextPositioningElements());
294 return;
295 }
296
297 // Always protect the cache before clearing text positioning elements when the cache will subsequently be rebuilt.
298 FontCachePurgePreventer fontCachePurgePreventer;
299
300 // The positioning elements cache depends on the size of each text renderer in the
301 // subtree. If this changes, clear the cache. It's going to be rebuilt below.
302 m_layoutAttributesBuilder.clearTextPositioningElements();
303
304 checkLayoutAttributesConsistency(this, m_layoutAttributes);
305 for (RenderObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
306 if (descendant->isSVGInlineText())
307 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(toRenderSVGInlineText(descendant));
308 }
309 }
310
updateFontInAllDescendants(RenderObject * start,SVGTextLayoutAttributesBuilder * builder=0)311 static inline void updateFontInAllDescendants(RenderObject* start, SVGTextLayoutAttributesBuilder* builder = 0)
312 {
313 for (RenderObject* descendant = start; descendant; descendant = descendant->nextInPreOrder(start)) {
314 if (!descendant->isSVGInlineText())
315 continue;
316 RenderSVGInlineText* text = toRenderSVGInlineText(descendant);
317 text->updateScaledFont();
318 if (builder)
319 builder->rebuildMetricsForTextRenderer(text);
320 }
321 }
322
layout()323 void RenderSVGText::layout()
324 {
325 ASSERT(needsLayout());
326
327 subtreeStyleDidChange();
328
329 bool updateCachedBoundariesInParents = false;
330 if (m_needsTransformUpdate) {
331 m_localTransform = toSVGTextElement(node())->animatedLocalTransform();
332 m_needsTransformUpdate = false;
333 updateCachedBoundariesInParents = true;
334 }
335
336 if (!everHadLayout()) {
337 // When laying out initially, collect all layout attributes, build the character data map,
338 // and propogate resulting SVGLayoutAttributes to all RenderSVGInlineText children in the subtree.
339 ASSERT(m_layoutAttributes.isEmpty());
340 collectLayoutAttributes(this, m_layoutAttributes);
341 updateFontInAllDescendants(this);
342 m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(this);
343
344 m_needsReordering = true;
345 m_needsTextMetricsUpdate = false;
346 m_needsPositioningValuesUpdate = false;
347 updateCachedBoundariesInParents = true;
348 } else if (m_needsPositioningValuesUpdate) {
349 // When the x/y/dx/dy/rotate lists change, recompute the layout attributes, and eventually
350 // update the on-screen font objects as well in all descendants.
351 if (m_needsTextMetricsUpdate) {
352 updateFontInAllDescendants(this);
353 m_needsTextMetricsUpdate = false;
354 }
355
356 m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(this);
357 m_needsReordering = true;
358 m_needsPositioningValuesUpdate = false;
359 updateCachedBoundariesInParents = true;
360 } else if (m_needsTextMetricsUpdate || SVGRenderSupport::findTreeRootObject(this)->isLayoutSizeChanged()) {
361 // If the root layout size changed (eg. window size changes) or the transform to the root
362 // context has changed then recompute the on-screen font size.
363 updateFontInAllDescendants(this, &m_layoutAttributesBuilder);
364
365 ASSERT(!m_needsReordering);
366 ASSERT(!m_needsPositioningValuesUpdate);
367 m_needsTextMetricsUpdate = false;
368 updateCachedBoundariesInParents = true;
369 }
370
371 checkLayoutAttributesConsistency(this, m_layoutAttributes);
372
373 // Reduced version of RenderBlock::layoutBlock(), which only takes care of SVG text.
374 // All if branches that could cause early exit in RenderBlocks layoutBlock() method are turned into assertions.
375 ASSERT(!isInline());
376 ASSERT(!simplifiedLayout());
377 ASSERT(!scrollsOverflow());
378 ASSERT(!hasControlClip());
379 ASSERT(!hasColumns());
380 ASSERT(!positionedObjects());
381 ASSERT(!m_overflow);
382 ASSERT(!isAnonymousBlock());
383
384 if (!firstChild())
385 setChildrenInline(true);
386
387 // FIXME: We need to find a way to only layout the child boxes, if needed.
388 FloatRect oldBoundaries = objectBoundingBox();
389 ASSERT(childrenInline());
390
391 rebuildFloatsFromIntruding();
392
393 LayoutUnit beforeEdge = borderBefore() + paddingBefore();
394 LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
395 setLogicalHeight(beforeEdge);
396
397 LayoutUnit paintInvalidationLogicalTop = 0;
398 LayoutUnit paintInvalidationLogicalBottom = 0;
399 layoutInlineChildren(true, paintInvalidationLogicalTop, paintInvalidationLogicalBottom, afterEdge);
400
401 if (m_needsReordering)
402 m_needsReordering = false;
403
404 if (!updateCachedBoundariesInParents)
405 updateCachedBoundariesInParents = oldBoundaries != objectBoundingBox();
406
407 // Invalidate all resources of this client if our layout changed.
408 if (everHadLayout() && selfNeedsLayout())
409 SVGResourcesCache::clientLayoutChanged(this);
410
411 // If our bounds changed, notify the parents.
412 if (updateCachedBoundariesInParents)
413 RenderSVGBlock::setNeedsBoundariesUpdate();
414
415 clearNeedsLayout();
416 }
417
createRootInlineBox()418 RootInlineBox* RenderSVGText::createRootInlineBox()
419 {
420 RootInlineBox* box = new SVGRootInlineBox(*this);
421 box->setHasVirtualLogicalHeight();
422 return box;
423 }
424
nodeAtFloatPoint(const HitTestRequest & request,HitTestResult & result,const FloatPoint & pointInParent,HitTestAction hitTestAction)425 bool RenderSVGText::nodeAtFloatPoint(const HitTestRequest& request, HitTestResult& result, const FloatPoint& pointInParent, HitTestAction hitTestAction)
426 {
427 PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING, request, style()->pointerEvents());
428 bool isVisible = (style()->visibility() == VISIBLE);
429 if (isVisible || !hitRules.requireVisible) {
430 if ((hitRules.canHitBoundingBox && !objectBoundingBox().isEmpty())
431 || (hitRules.canHitStroke && (style()->svgStyle().hasStroke() || !hitRules.requireStroke))
432 || (hitRules.canHitFill && (style()->svgStyle().hasFill() || !hitRules.requireFill))) {
433 FloatPoint localPoint;
434 if (!SVGRenderSupport::transformToUserSpaceAndCheckClipping(this, localToParentTransform(), pointInParent, localPoint))
435 return false;
436
437 if (hitRules.canHitBoundingBox && !objectBoundingBox().contains(localPoint))
438 return false;
439
440 HitTestLocation hitTestLocation(LayoutPoint(flooredIntPoint(localPoint)));
441 return RenderBlock::nodeAtPoint(request, result, hitTestLocation, LayoutPoint(), hitTestAction);
442 }
443 }
444
445 return false;
446 }
447
positionForPoint(const LayoutPoint & pointInContents)448 PositionWithAffinity RenderSVGText::positionForPoint(const LayoutPoint& pointInContents)
449 {
450 RootInlineBox* rootBox = firstRootBox();
451 if (!rootBox)
452 return createPositionWithAffinity(0, DOWNSTREAM);
453
454 ASSERT(!rootBox->nextRootBox());
455 ASSERT(childrenInline());
456
457 InlineBox* closestBox = toSVGRootInlineBox(rootBox)->closestLeafChildForPosition(pointInContents);
458 if (!closestBox)
459 return createPositionWithAffinity(0, DOWNSTREAM);
460
461 return closestBox->renderer().positionForPoint(LayoutPoint(pointInContents.x(), closestBox->y()));
462 }
463
absoluteQuads(Vector<FloatQuad> & quads,bool * wasFixed) const464 void RenderSVGText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
465 {
466 quads.append(localToAbsoluteQuad(strokeBoundingBox(), 0 /* mode */, wasFixed));
467 }
468
paint(PaintInfo & paintInfo,const LayoutPoint &)469 void RenderSVGText::paint(PaintInfo& paintInfo, const LayoutPoint&)
470 {
471 SVGTextPainter(*this).paint(paintInfo);
472 }
473
strokeBoundingBox() const474 FloatRect RenderSVGText::strokeBoundingBox() const
475 {
476 FloatRect strokeBoundaries = objectBoundingBox();
477 const SVGRenderStyle& svgStyle = style()->svgStyle();
478 if (!svgStyle.hasStroke())
479 return strokeBoundaries;
480
481 ASSERT(node());
482 ASSERT(node()->isSVGElement());
483 SVGLengthContext lengthContext(toSVGElement(node()));
484 strokeBoundaries.inflate(svgStyle.strokeWidth()->value(lengthContext));
485 return strokeBoundaries;
486 }
487
paintInvalidationRectInLocalCoordinates() const488 FloatRect RenderSVGText::paintInvalidationRectInLocalCoordinates() const
489 {
490 FloatRect paintInvalidationRect = strokeBoundingBox();
491 SVGRenderSupport::intersectPaintInvalidationRectWithResources(this, paintInvalidationRect);
492
493 if (const ShadowList* textShadow = style()->textShadow())
494 textShadow->adjustRectForShadow(paintInvalidationRect);
495
496 return paintInvalidationRect;
497 }
498
addChild(RenderObject * child,RenderObject * beforeChild)499 void RenderSVGText::addChild(RenderObject* child, RenderObject* beforeChild)
500 {
501 RenderSVGBlock::addChild(child, beforeChild);
502
503 SVGResourcesCache::clientWasAddedToTree(child, child->style());
504 subtreeChildWasAdded(child);
505 }
506
removeChild(RenderObject * child)507 void RenderSVGText::removeChild(RenderObject* child)
508 {
509 SVGResourcesCache::clientWillBeRemovedFromTree(child);
510
511 Vector<SVGTextLayoutAttributes*, 2> affectedAttributes;
512 FontCachePurgePreventer fontCachePurgePreventer;
513 subtreeChildWillBeRemoved(child, affectedAttributes);
514 RenderSVGBlock::removeChild(child);
515 subtreeChildWasRemoved(affectedAttributes);
516 }
517
518 }
519