Apply SVG styles paint-order, stroke-linejoin, and stroke-linecap on DOM text.
[WebKit-https.git] / Source / WebCore / rendering / svg / SVGInlineTextBox.cpp
1 /**
2  * Copyright (C) 2007 Rob Buis <buis@kde.org>
3  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
4  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23 #include "SVGInlineTextBox.h"
24
25 #include "Frame.h"
26 #include "FrameView.h"
27 #include "GraphicsContext.h"
28 #include "HitTestResult.h"
29 #include "InlineFlowBox.h"
30 #include "PointerEventsHitRules.h"
31 #include "RenderBlock.h"
32 #include "RenderInline.h"
33 #include "RenderSVGResourceSolidColor.h"
34 #include "RenderView.h"
35 #include "SVGRenderingContext.h"
36 #include "SVGResourcesCache.h"
37 #include "SVGRootInlineBox.h"
38 #include "TextPainter.h"
39
40 namespace WebCore {
41
42 struct ExpectedSVGInlineTextBoxSize : public InlineTextBox {
43     float float1;
44     uint32_t bitfields : 5;
45     void* pointer;
46     Vector<SVGTextFragment> vector;
47 };
48
49 COMPILE_ASSERT(sizeof(SVGInlineTextBox) == sizeof(ExpectedSVGInlineTextBoxSize), SVGInlineTextBox_is_not_of_expected_size);
50
51 SVGInlineTextBox::SVGInlineTextBox(RenderSVGInlineText& renderer)
52     : InlineTextBox(renderer)
53     , m_logicalHeight(0)
54     , m_paintingResourceMode(ApplyToDefaultMode)
55     , m_startsNewTextChunk(false)
56     , m_paintingResource(nullptr)
57 {
58 }
59
60 void SVGInlineTextBox::dirtyOwnLineBoxes()
61 {
62     InlineTextBox::dirtyLineBoxes();
63
64     // Clear the now stale text fragments
65     clearTextFragments();
66 }
67
68 void SVGInlineTextBox::dirtyLineBoxes()
69 {
70     dirtyOwnLineBoxes();
71
72     // And clear any following text fragments as the text on which they
73     // depend may now no longer exist, or glyph positions may be wrong
74     for (InlineTextBox* nextBox = nextTextBox(); nextBox; nextBox = nextBox->nextTextBox())
75         nextBox->dirtyOwnLineBoxes();
76 }
77
78 int SVGInlineTextBox::offsetForPosition(float, bool) const
79 {
80     // SVG doesn't use the standard offset <-> position selection system, as it's not suitable for SVGs complex needs.
81     // vertical text selection, inline boxes spanning multiple lines (contrary to HTML, etc.)
82     ASSERT_NOT_REACHED();
83     return 0;
84 }
85
86 int SVGInlineTextBox::offsetForPositionInFragment(const SVGTextFragment& fragment, float position, bool includePartialGlyphs) const
87 {
88    float scalingFactor = renderer().scalingFactor();
89     ASSERT(scalingFactor);
90
91     TextRun textRun = constructTextRun(renderer().style(), fragment);
92
93     // Eventually handle lengthAdjust="spacingAndGlyphs".
94     // FIXME: Handle vertical text.
95     AffineTransform fragmentTransform;
96     fragment.buildFragmentTransform(fragmentTransform);
97     if (!fragmentTransform.isIdentity())
98         textRun.setHorizontalGlyphStretch(narrowPrecisionToFloat(fragmentTransform.xScale()));
99
100     return fragment.characterOffset - start() + renderer().scaledFont().offsetForPosition(textRun, position * scalingFactor, includePartialGlyphs);
101 }
102
103 float SVGInlineTextBox::positionForOffset(unsigned) const
104 {
105     // SVG doesn't use the offset <-> position selection system. 
106     ASSERT_NOT_REACHED();
107     return 0;
108 }
109
110 FloatRect SVGInlineTextBox::selectionRectForTextFragment(const SVGTextFragment& fragment, unsigned startPosition, unsigned endPosition, const RenderStyle& style) const
111 {
112     ASSERT_WITH_SECURITY_IMPLICATION(startPosition < endPosition);
113
114     float scalingFactor = renderer().scalingFactor();
115     ASSERT(scalingFactor);
116
117     const FontCascade& scaledFont = renderer().scaledFont();
118     const FontMetrics& scaledFontMetrics = scaledFont.fontMetrics();
119     FloatPoint textOrigin(fragment.x, fragment.y);
120     if (scalingFactor != 1)
121         textOrigin.scale(scalingFactor);
122
123     textOrigin.move(0, -scaledFontMetrics.floatAscent());
124
125     LayoutRect selectionRect = LayoutRect(textOrigin, LayoutSize(0, fragment.height * scalingFactor));
126     TextRun run = constructTextRun(style, fragment);
127     scaledFont.adjustSelectionRectForText(run, selectionRect, startPosition, endPosition);
128     FloatRect snappedSelectionRect = snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), run.ltr());
129     if (scalingFactor == 1)
130         return snappedSelectionRect;
131
132     snappedSelectionRect.scale(1 / scalingFactor);
133     return snappedSelectionRect;
134 }
135
136 LayoutRect SVGInlineTextBox::localSelectionRect(unsigned startPosition, unsigned endPosition) const
137 {
138     startPosition = clampedOffset(startPosition);
139     endPosition = clampedOffset(endPosition);
140     if (startPosition >= endPosition)
141         return LayoutRect();
142
143     auto& style = renderer().style();
144
145     AffineTransform fragmentTransform;
146     FloatRect selectionRect;
147     unsigned fragmentStartPosition = 0;
148     unsigned fragmentEndPosition = 0;
149
150     unsigned textFragmentsSize = m_textFragments.size();
151     for (unsigned i = 0; i < textFragmentsSize; ++i) {
152         const SVGTextFragment& fragment = m_textFragments.at(i);
153
154         fragmentStartPosition = startPosition;
155         fragmentEndPosition = endPosition;
156         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
157             continue;
158
159         FloatRect fragmentRect = selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, style);
160         fragment.buildFragmentTransform(fragmentTransform);
161         if (!fragmentTransform.isIdentity())
162             fragmentRect = fragmentTransform.mapRect(fragmentRect);
163
164         selectionRect.unite(fragmentRect);
165     }
166
167     return enclosingIntRect(selectionRect);
168 }
169
170 static inline bool textShouldBePainted(const RenderSVGInlineText& textRenderer)
171 {
172     // FontCascade::pixelSize(), returns FontDescription::computedPixelSize(), which returns "int(x + 0.5)".
173     // If the absolute font size on screen is below x=0.5, don't render anything.
174     return textRenderer.scaledFont().pixelSize();
175 }
176
177 void SVGInlineTextBox::paintSelectionBackground(PaintInfo& paintInfo)
178 {
179     ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
180     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
181     ASSERT(truncation() == cNoTruncation);
182
183     if (renderer().style().visibility() != VISIBLE)
184         return;
185
186     auto& parentRenderer = parent()->renderer();
187     ASSERT(!parentRenderer.document().printing());
188
189     // Determine whether or not we're selected.
190     bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
191     bool hasSelection = selectionState() != RenderObject::SelectionNone;
192     if (!hasSelection || paintSelectedTextOnly)
193         return;
194
195     Color backgroundColor = renderer().selectionBackgroundColor();
196     if (!backgroundColor.isVisible())
197         return;
198
199     if (!textShouldBePainted(renderer()))
200         return;
201
202     auto& style = parentRenderer.style();
203
204     unsigned startPosition;
205     unsigned endPosition;
206     std::tie(startPosition, endPosition) = selectionStartEnd();
207
208     unsigned fragmentStartPosition = 0;
209     unsigned fragmentEndPosition = 0;
210     AffineTransform fragmentTransform;
211     unsigned textFragmentsSize = m_textFragments.size();
212     for (unsigned i = 0; i < textFragmentsSize; ++i) {
213         SVGTextFragment& fragment = m_textFragments.at(i);
214         ASSERT(!m_paintingResource);
215
216         fragmentStartPosition = startPosition;
217         fragmentEndPosition = endPosition;
218         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
219             continue;
220
221         GraphicsContextStateSaver stateSaver(paintInfo.context());
222         fragment.buildFragmentTransform(fragmentTransform);
223         if (!fragmentTransform.isIdentity())
224             paintInfo.context().concatCTM(fragmentTransform);
225
226         paintInfo.context().setFillColor(backgroundColor);
227         paintInfo.context().fillRect(selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, style), backgroundColor);
228
229         m_paintingResourceMode = ApplyToDefaultMode;
230     }
231
232     ASSERT(!m_paintingResource);
233 }
234
235 void SVGInlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit, LayoutUnit)
236 {
237     ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
238     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
239     ASSERT(truncation() == cNoTruncation);
240
241     if (renderer().style().visibility() != VISIBLE)
242         return;
243
244     // Note: We're explicitely not supporting composition & custom underlines and custom highlighters - unlike InlineTextBox.
245     // If we ever need that for SVG, it's very easy to refactor and reuse the code.
246
247     auto& parentRenderer = parent()->renderer();
248
249     bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
250     bool shouldPaintSelectionHighlight = !(paintInfo.paintBehavior & PaintBehaviorSkipSelectionHighlight);
251     bool hasSelection = !parentRenderer.document().printing() && selectionState() != RenderObject::SelectionNone;
252     if (!hasSelection && paintSelectedTextOnly)
253         return;
254
255     if (!textShouldBePainted(renderer()))
256         return;
257
258     auto& style = parentRenderer.style();
259
260     const SVGRenderStyle& svgStyle = style.svgStyle();
261
262     bool hasFill = svgStyle.hasFill();
263     bool hasVisibleStroke = style.hasVisibleStroke();
264
265     const RenderStyle* selectionStyle = &style;
266     if (hasSelection && shouldPaintSelectionHighlight) {
267         selectionStyle = parentRenderer.getCachedPseudoStyle(SELECTION);
268         if (selectionStyle) {
269             const SVGRenderStyle& svgSelectionStyle = selectionStyle->svgStyle();
270
271             if (!hasFill)
272                 hasFill = svgSelectionStyle.hasFill();
273             if (!hasVisibleStroke)
274                 hasVisibleStroke = selectionStyle->hasVisibleStroke();
275         } else
276             selectionStyle = &style;
277     }
278
279     if (renderer().view().frameView().paintBehavior() & PaintBehaviorRenderingSVGMask) {
280         hasFill = true;
281         hasVisibleStroke = false;
282     }
283
284     AffineTransform fragmentTransform;
285     unsigned textFragmentsSize = m_textFragments.size();
286     for (unsigned i = 0; i < textFragmentsSize; ++i) {
287         SVGTextFragment& fragment = m_textFragments.at(i);
288         ASSERT(!m_paintingResource);
289
290         GraphicsContextStateSaver stateSaver(paintInfo.context());
291         fragment.buildFragmentTransform(fragmentTransform);
292         if (!fragmentTransform.isIdentity())
293             paintInfo.context().concatCTM(fragmentTransform);
294
295         // Spec: All text decorations except line-through should be drawn before the text is filled and stroked; thus, the text is rendered on top of these decorations.
296         int decorations = style.textDecorationsInEffect();
297         if (decorations & TextDecorationUnderline)
298             paintDecoration(paintInfo.context(), TextDecorationUnderline, fragment);
299         if (decorations & TextDecorationOverline)
300             paintDecoration(paintInfo.context(), TextDecorationOverline, fragment);
301
302         auto paintOrder = style.paintTypesForPaintOrder();
303         for (unsigned i = 0; i < paintOrder.size(); ++i) {
304             switch (paintOrder.at(i)) {
305             case PaintTypeFill:
306                 if (!hasFill)
307                     continue;
308                 m_paintingResourceMode = ApplyToFillMode | ApplyToTextMode;
309                 ASSERT(selectionStyle);
310                 paintText(paintInfo.context(), style, *selectionStyle, fragment, hasSelection, paintSelectedTextOnly);
311                 break;
312             case PaintTypeStroke:
313                 if (!hasVisibleStroke)
314                     continue;
315                 m_paintingResourceMode = ApplyToStrokeMode | ApplyToTextMode;
316                 ASSERT(selectionStyle);
317                 paintText(paintInfo.context(), style, *selectionStyle, fragment, hasSelection, paintSelectedTextOnly);
318                 break;
319             case PaintTypeMarkers:
320                 continue;
321             }
322         }
323
324         // Spec: Line-through should be drawn after the text is filled and stroked; thus, the line-through is rendered on top of the text.
325         if (decorations & TextDecorationLineThrough)
326             paintDecoration(paintInfo.context(), TextDecorationLineThrough, fragment);
327
328         m_paintingResourceMode = ApplyToDefaultMode;
329     }
330
331     // Finally, paint the outline if any.
332     if (renderer().style().hasOutline() && is<RenderInline>(parentRenderer))
333         downcast<RenderInline>(parentRenderer).paintOutline(paintInfo, paintOffset);
334
335     ASSERT(!m_paintingResource);
336 }
337
338 bool SVGInlineTextBox::acquirePaintingResource(GraphicsContext*& context, float scalingFactor, RenderBoxModelObject& renderer, const RenderStyle& style)
339 {
340     ASSERT(scalingFactor);
341     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
342
343     Color fallbackColor;
344     if (m_paintingResourceMode & ApplyToFillMode)
345         m_paintingResource = RenderSVGResource::fillPaintingResource(renderer, style, fallbackColor);
346     else if (m_paintingResourceMode & ApplyToStrokeMode)
347         m_paintingResource = RenderSVGResource::strokePaintingResource(renderer, style, fallbackColor);
348     else {
349         // We're either called for stroking or filling.
350         ASSERT_NOT_REACHED();
351     }
352
353     if (!m_paintingResource)
354         return false;
355
356     if (!m_paintingResource->applyResource(renderer, style, context, m_paintingResourceMode)) {
357         if (fallbackColor.isValid()) {
358             RenderSVGResourceSolidColor* fallbackResource = RenderSVGResource::sharedSolidPaintingResource();
359             fallbackResource->setColor(fallbackColor);
360
361             m_paintingResource = fallbackResource;
362             m_paintingResource->applyResource(renderer, style, context, m_paintingResourceMode);
363         }
364     }
365
366     if (scalingFactor != 1 && m_paintingResourceMode & ApplyToStrokeMode)
367         context->setStrokeThickness(context->strokeThickness() * scalingFactor);
368
369     return true;
370 }
371
372 void SVGInlineTextBox::releasePaintingResource(GraphicsContext*& context, const Path* path)
373 {
374     ASSERT(m_paintingResource);
375
376     m_paintingResource->postApplyResource(parent()->renderer(), context, m_paintingResourceMode, path, /*RenderSVGShape*/ nullptr);
377     m_paintingResource = nullptr;
378 }
379
380 bool SVGInlineTextBox::prepareGraphicsContextForTextPainting(GraphicsContext*& context, float scalingFactor, const RenderStyle& style)
381 {
382     return acquirePaintingResource(context, scalingFactor, parent()->renderer(), style);
383 }
384
385 void SVGInlineTextBox::restoreGraphicsContextAfterTextPainting(GraphicsContext*& context)
386 {
387     releasePaintingResource(context, /* path */nullptr);
388 }
389
390 TextRun SVGInlineTextBox::constructTextRun(const RenderStyle& style, const SVGTextFragment& fragment) const
391 {
392     TextRun run(StringView(renderer().text()).substring(fragment.characterOffset, fragment.length)
393                 , 0 /* xPos, only relevant with allowTabs=true */
394                 , 0 /* padding, only relevant for justified text, not relevant for SVG */
395                 , AllowTrailingExpansion
396                 , direction()
397                 , dirOverride() || style.rtlOrdering() == VisualOrder /* directionalOverride */);
398
399     // We handle letter & word spacing ourselves.
400     run.disableSpacing();
401
402     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
403     run.setCharactersLength(renderer().textLength() - fragment.characterOffset);
404     ASSERT(run.charactersLength() >= run.length());
405     return run;
406 }
407
408 bool SVGInlineTextBox::mapStartEndPositionsIntoFragmentCoordinates(const SVGTextFragment& fragment, unsigned& startPosition, unsigned& endPosition) const
409 {
410     if (startPosition >= endPosition)
411         return false;
412
413     ASSERT(fragment.characterOffset >= start());
414     unsigned offset = fragment.characterOffset - start();
415     unsigned length = fragment.length;
416
417     if (startPosition >= offset + length || endPosition <= offset)
418         return false;
419
420     if (startPosition < offset)
421         startPosition = 0;
422     else {
423         ASSERT(startPosition >= offset);
424         startPosition -= offset;
425     }
426
427     if (endPosition > offset + length)
428         endPosition = length;
429     else {
430         ASSERT(endPosition >= offset);
431         endPosition -= offset;
432     }
433
434     ASSERT_WITH_SECURITY_IMPLICATION(startPosition < endPosition);
435     return true;
436 }
437
438 static inline float positionOffsetForDecoration(TextDecoration decoration, const FontMetrics& fontMetrics, float thickness)
439 {
440     // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
441     // Compatible with Batik/Opera.
442     if (decoration == TextDecorationUnderline)
443         return fontMetrics.floatAscent() + thickness * 1.5f;
444     if (decoration == TextDecorationOverline)
445         return thickness;
446     if (decoration == TextDecorationLineThrough)
447         return fontMetrics.floatAscent() * 5 / 8.0f;
448
449     ASSERT_NOT_REACHED();
450     return 0.0f;
451 }
452
453 static inline float thicknessForDecoration(TextDecoration, const FontCascade& font)
454 {
455     // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
456     // Compatible with Batik/Opera
457     return font.size() / 20.0f;
458 }
459
460 static inline RenderBoxModelObject& findRendererDefininingTextDecoration(InlineFlowBox* parentBox)
461 {
462     // Lookup first render object in parent hierarchy which has text-decoration set.
463     RenderBoxModelObject* renderer = nullptr;
464     while (parentBox) {
465         renderer = &parentBox->renderer();
466
467         if (renderer->style().textDecoration() != TextDecorationNone)
468             break;
469
470         parentBox = parentBox->parent();
471     }
472
473     ASSERT(renderer);
474     return *renderer;
475 }
476
477 void SVGInlineTextBox::paintDecoration(GraphicsContext& context, TextDecoration decoration, const SVGTextFragment& fragment)
478 {
479     if (renderer().style().textDecorationsInEffect() == TextDecorationNone)
480         return;
481
482     // Find out which render style defined the text-decoration, as its fill/stroke properties have to be used for drawing instead of ours.
483     auto& decorationRenderer = findRendererDefininingTextDecoration(parent());
484     const RenderStyle& decorationStyle = decorationRenderer.style();
485
486     if (decorationStyle.visibility() == HIDDEN)
487         return;
488
489     const SVGRenderStyle& svgDecorationStyle = decorationStyle.svgStyle();
490
491     bool hasDecorationFill = svgDecorationStyle.hasFill();
492     bool hasVisibleDecorationStroke = decorationStyle.hasVisibleStroke();
493
494     if (hasDecorationFill) {
495         m_paintingResourceMode = ApplyToFillMode;
496         paintDecorationWithStyle(context, decoration, fragment, decorationRenderer);
497     }
498
499     if (hasVisibleDecorationStroke) {
500         m_paintingResourceMode = ApplyToStrokeMode;
501         paintDecorationWithStyle(context, decoration, fragment, decorationRenderer);
502     }
503 }
504
505 void SVGInlineTextBox::paintDecorationWithStyle(GraphicsContext& context, TextDecoration decoration, const SVGTextFragment& fragment, RenderBoxModelObject& decorationRenderer)
506 {
507     ASSERT(!m_paintingResource);
508     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
509
510     auto& decorationStyle = decorationRenderer.style();
511
512     float scalingFactor = 1;
513     FontCascade scaledFont;
514     RenderSVGInlineText::computeNewScaledFontForStyle(decorationRenderer, decorationStyle, scalingFactor, scaledFont);
515     ASSERT(scalingFactor);
516
517     // The initial y value refers to overline position.
518     float thickness = thicknessForDecoration(decoration, scaledFont);
519
520     if (fragment.width <= 0 && thickness <= 0)
521         return;
522
523     FloatPoint decorationOrigin(fragment.x, fragment.y);
524     float width = fragment.width;
525     const FontMetrics& scaledFontMetrics = scaledFont.fontMetrics();
526
527     GraphicsContextStateSaver stateSaver(context);
528     if (scalingFactor != 1) {
529         width *= scalingFactor;
530         decorationOrigin.scale(scalingFactor);
531         context.scale(1 / scalingFactor);
532     }
533
534     decorationOrigin.move(0, -scaledFontMetrics.floatAscent() + positionOffsetForDecoration(decoration, scaledFontMetrics, thickness));
535
536     Path path;
537     path.addRect(FloatRect(decorationOrigin, FloatSize(width, thickness)));
538
539     GraphicsContext* contextPtr = &context;
540     if (acquirePaintingResource(contextPtr, scalingFactor, decorationRenderer, decorationStyle))
541         releasePaintingResource(contextPtr, &path);
542 }
543
544 void SVGInlineTextBox::paintTextWithShadows(GraphicsContext& context, const RenderStyle& style, TextRun& textRun, const SVGTextFragment& fragment, unsigned startPosition, unsigned endPosition)
545 {
546     float scalingFactor = renderer().scalingFactor();
547     ASSERT(scalingFactor);
548
549     const FontCascade& scaledFont = renderer().scaledFont();
550     const ShadowData* shadow = style.textShadow();
551
552     FloatPoint textOrigin(fragment.x, fragment.y);
553     FloatSize textSize(fragment.width, fragment.height);
554
555     if (scalingFactor != 1) {
556         textOrigin.scale(scalingFactor);
557         textSize.scale(scalingFactor);
558     }
559
560     FloatRect shadowRect(FloatPoint(textOrigin.x(), textOrigin.y() - scaledFont.fontMetrics().floatAscent()), textSize);
561
562     GraphicsContext* usedContext = &context;
563     do {
564         if (!prepareGraphicsContextForTextPainting(usedContext, scalingFactor, style))
565             break;
566
567         {
568             ShadowApplier shadowApplier(*usedContext, shadow, shadowRect);
569
570             if (!shadowApplier.didSaveContext())
571                 usedContext->save();
572             usedContext->scale(1 / scalingFactor);
573
574             scaledFont.drawText(*usedContext, textRun, textOrigin + shadowApplier.extraOffset(), startPosition, endPosition);
575
576             if (!shadowApplier.didSaveContext())
577                 usedContext->restore();
578         }
579
580         restoreGraphicsContextAfterTextPainting(usedContext);
581
582         if (!shadow)
583             break;
584
585         shadow = shadow->next();
586     } while (shadow);
587 }
588
589 void SVGInlineTextBox::paintText(GraphicsContext& context, const RenderStyle& style, const RenderStyle& selectionStyle, const SVGTextFragment& fragment, bool hasSelection, bool paintSelectedTextOnly)
590 {
591     unsigned startPosition = 0;
592     unsigned endPosition = 0;
593     if (hasSelection) {
594         std::tie(startPosition, endPosition) = selectionStartEnd();
595         hasSelection = mapStartEndPositionsIntoFragmentCoordinates(fragment, startPosition, endPosition);
596     }
597
598     // Fast path if there is no selection, just draw the whole chunk part using the regular style
599     TextRun textRun = constructTextRun(style, fragment);
600     if (!hasSelection || startPosition >= endPosition) {
601         paintTextWithShadows(context, style, textRun, fragment, 0, fragment.length);
602         return;
603     }
604
605     // Eventually draw text using regular style until the start position of the selection
606     if (startPosition > 0 && !paintSelectedTextOnly)
607         paintTextWithShadows(context, style, textRun, fragment, 0, startPosition);
608
609     // Draw text using selection style from the start to the end position of the selection
610     if (style != selectionStyle)
611         SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, selectionStyle);
612
613     paintTextWithShadows(context, selectionStyle, textRun, fragment, startPosition, endPosition);
614
615     if (style != selectionStyle)
616         SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, style);
617
618     // Eventually draw text using regular style from the end position of the selection to the end of the current chunk part
619     if (endPosition < fragment.length && !paintSelectedTextOnly)
620         paintTextWithShadows(context, style, textRun, fragment, endPosition, fragment.length);
621 }
622
623 FloatRect SVGInlineTextBox::calculateBoundaries() const
624 {
625     FloatRect textRect;
626
627     float scalingFactor = renderer().scalingFactor();
628     ASSERT(scalingFactor);
629
630     float baseline = renderer().scaledFont().fontMetrics().floatAscent() / scalingFactor;
631
632     AffineTransform fragmentTransform;
633     unsigned textFragmentsSize = m_textFragments.size();
634     for (unsigned i = 0; i < textFragmentsSize; ++i) {
635         const SVGTextFragment& fragment = m_textFragments.at(i);
636         FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
637         fragment.buildFragmentTransform(fragmentTransform);
638         if (!fragmentTransform.isIdentity())
639             fragmentRect = fragmentTransform.mapRect(fragmentRect);
640
641         textRect.unite(fragmentRect);
642     }
643
644     return textRect;
645 }
646
647 bool SVGInlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit, LayoutUnit, HitTestAction)
648 {
649     // FIXME: integrate with InlineTextBox::nodeAtPoint better.
650     ASSERT(!isLineBreak());
651
652     PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING, request, renderer().style().pointerEvents());
653     bool isVisible = renderer().style().visibility() == VISIBLE;
654     if (isVisible || !hitRules.requireVisible) {
655         if ((hitRules.canHitStroke && (renderer().style().svgStyle().hasStroke() || !hitRules.requireStroke))
656             || (hitRules.canHitFill && (renderer().style().svgStyle().hasFill() || !hitRules.requireFill))) {
657             FloatPoint boxOrigin(x(), y());
658             boxOrigin.moveBy(accumulatedOffset);
659             FloatRect rect(boxOrigin, size());
660             if (locationInContainer.intersects(rect)) {
661
662                 float scalingFactor = renderer().scalingFactor();
663                 ASSERT(scalingFactor);
664                 
665                 float baseline = renderer().scaledFont().fontMetrics().floatAscent() / scalingFactor;
666
667                 AffineTransform fragmentTransform;
668                 for (auto& fragment : m_textFragments) {
669                     FloatQuad fragmentQuad(FloatRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height));
670                     fragment.buildFragmentTransform(fragmentTransform);
671                     if (!fragmentTransform.isIdentity())
672                         fragmentQuad = fragmentTransform.mapQuad(fragmentQuad);
673                     
674                     if (fragmentQuad.containsPoint(locationInContainer.point())) {
675                         renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
676                         if (!result.addNodeToRectBasedTestResult(&renderer().textNode(), request, locationInContainer, rect))
677                             return true;
678                     }
679                 }
680              }
681         }
682     }
683     return false;
684 }
685
686 } // namespace WebCore