a4f419fd6a8f9b4cfd858bd32cfd0d53a8a48950
[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(int) 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, int startPosition, int endPosition, const RenderStyle* style) const
111 {
112     ASSERT_WITH_SECURITY_IMPLICATION(startPosition < endPosition);
113     ASSERT(style);
114
115     float scalingFactor = renderer().scalingFactor();
116     ASSERT(scalingFactor);
117
118     const FontCascade& scaledFont = renderer().scaledFont();
119     const FontMetrics& scaledFontMetrics = scaledFont.fontMetrics();
120     FloatPoint textOrigin(fragment.x, fragment.y);
121     if (scalingFactor != 1)
122         textOrigin.scale(scalingFactor, scalingFactor);
123
124     textOrigin.move(0, -scaledFontMetrics.floatAscent());
125
126     LayoutRect selectionRect = LayoutRect(textOrigin, LayoutSize(0, fragment.height * scalingFactor));
127     TextRun run = constructTextRun(style, fragment);
128     scaledFont.adjustSelectionRectForText(run, selectionRect, startPosition, endPosition);
129     FloatRect snappedSelectionRect = snapRectToDevicePixelsWithWritingDirection(selectionRect, renderer().document().deviceScaleFactor(), run.ltr());
130     if (scalingFactor == 1)
131         return snappedSelectionRect;
132
133     snappedSelectionRect.scale(1 / scalingFactor);
134     return snappedSelectionRect;
135 }
136
137 LayoutRect SVGInlineTextBox::localSelectionRect(int startPosition, int endPosition) const
138 {
139     int boxStart = start();
140     startPosition = std::max(startPosition - boxStart, 0);
141     endPosition = std::min(endPosition - boxStart, static_cast<int>(len()));
142     if (startPosition >= endPosition)
143         return LayoutRect();
144
145     auto& style = renderer().style();
146
147     AffineTransform fragmentTransform;
148     FloatRect selectionRect;
149     int fragmentStartPosition = 0;
150     int fragmentEndPosition = 0;
151
152     unsigned textFragmentsSize = m_textFragments.size();
153     for (unsigned i = 0; i < textFragmentsSize; ++i) {
154         const SVGTextFragment& fragment = m_textFragments.at(i);
155
156         fragmentStartPosition = startPosition;
157         fragmentEndPosition = endPosition;
158         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
159             continue;
160
161         FloatRect fragmentRect = selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, &style);
162         fragment.buildFragmentTransform(fragmentTransform);
163         if (!fragmentTransform.isIdentity())
164             fragmentRect = fragmentTransform.mapRect(fragmentRect);
165
166         selectionRect.unite(fragmentRect);
167     }
168
169     return enclosingIntRect(selectionRect);
170 }
171
172 static inline bool textShouldBePainted(const RenderSVGInlineText& textRenderer)
173 {
174     // FontCascade::pixelSize(), returns FontDescription::computedPixelSize(), which returns "int(x + 0.5)".
175     // If the absolute font size on screen is below x=0.5, don't render anything.
176     return textRenderer.scaledFont().pixelSize();
177 }
178
179 void SVGInlineTextBox::paintSelectionBackground(PaintInfo& paintInfo)
180 {
181     ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
182     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
183     ASSERT(truncation() == cNoTruncation);
184
185     if (renderer().style().visibility() != VISIBLE)
186         return;
187
188     auto& parentRenderer = parent()->renderer();
189     ASSERT(!parentRenderer.document().printing());
190
191     // Determine whether or not we're selected.
192     bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
193     bool hasSelection = selectionState() != RenderObject::SelectionNone;
194     if (!hasSelection || paintSelectedTextOnly)
195         return;
196
197     Color backgroundColor = renderer().selectionBackgroundColor();
198     if (!backgroundColor.isValid() || !backgroundColor.alpha())
199         return;
200
201     if (!textShouldBePainted(renderer()))
202         return;
203
204     auto& style = parentRenderer.style();
205
206     int startPosition;
207     int endPosition;
208     std::tie(startPosition, endPosition) = selectionStartEnd();
209
210     int fragmentStartPosition = 0;
211     int fragmentEndPosition = 0;
212     AffineTransform fragmentTransform;
213     unsigned textFragmentsSize = m_textFragments.size();
214     for (unsigned i = 0; i < textFragmentsSize; ++i) {
215         SVGTextFragment& fragment = m_textFragments.at(i);
216         ASSERT(!m_paintingResource);
217
218         fragmentStartPosition = startPosition;
219         fragmentEndPosition = endPosition;
220         if (!mapStartEndPositionsIntoFragmentCoordinates(fragment, fragmentStartPosition, fragmentEndPosition))
221             continue;
222
223         GraphicsContextStateSaver stateSaver(paintInfo.context());
224         fragment.buildFragmentTransform(fragmentTransform);
225         if (!fragmentTransform.isIdentity())
226             paintInfo.context().concatCTM(fragmentTransform);
227
228         paintInfo.context().setFillColor(backgroundColor);
229         paintInfo.context().fillRect(selectionRectForTextFragment(fragment, fragmentStartPosition, fragmentEndPosition, &style), backgroundColor);
230
231         m_paintingResourceMode = ApplyToDefaultMode;
232     }
233
234     ASSERT(!m_paintingResource);
235 }
236
237 void SVGInlineTextBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit, LayoutUnit)
238 {
239     ASSERT(paintInfo.shouldPaintWithinRoot(renderer()));
240     ASSERT(paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection);
241     ASSERT(truncation() == cNoTruncation);
242
243     if (renderer().style().visibility() != VISIBLE)
244         return;
245
246     // Note: We're explicitely not supporting composition & custom underlines and custom highlighters - unlike InlineTextBox.
247     // If we ever need that for SVG, it's very easy to refactor and reuse the code.
248
249     auto& parentRenderer = parent()->renderer();
250
251     bool paintSelectedTextOnly = paintInfo.phase == PaintPhaseSelection;
252     bool hasSelection = !parentRenderer.document().printing() && selectionState() != RenderObject::SelectionNone;
253     if (!hasSelection && paintSelectedTextOnly)
254         return;
255
256     if (!textShouldBePainted(renderer()))
257         return;
258
259     auto& style = parentRenderer.style();
260
261     const SVGRenderStyle& svgStyle = style.svgStyle();
262
263     bool hasFill = svgStyle.hasFill();
264     bool hasVisibleStroke = svgStyle.hasVisibleStroke();
265
266     const RenderStyle* selectionStyle = &style;
267     if (hasSelection) {
268         selectionStyle = parentRenderer.getCachedPseudoStyle(SELECTION);
269         if (selectionStyle) {
270             const SVGRenderStyle& svgSelectionStyle = selectionStyle->svgStyle();
271
272             if (!hasFill)
273                 hasFill = svgSelectionStyle.hasFill();
274             if (!hasVisibleStroke)
275                 hasVisibleStroke = svgSelectionStyle.hasVisibleStroke();
276         } else
277             selectionStyle = &style;
278     }
279
280     if (renderer().view().frameView().paintBehavior() & PaintBehaviorRenderingSVGMask) {
281         hasFill = true;
282         hasVisibleStroke = false;
283     }
284
285     AffineTransform fragmentTransform;
286     unsigned textFragmentsSize = m_textFragments.size();
287     for (unsigned i = 0; i < textFragmentsSize; ++i) {
288         SVGTextFragment& fragment = m_textFragments.at(i);
289         ASSERT(!m_paintingResource);
290
291         GraphicsContextStateSaver stateSaver(paintInfo.context());
292         fragment.buildFragmentTransform(fragmentTransform);
293         if (!fragmentTransform.isIdentity())
294             paintInfo.context().concatCTM(fragmentTransform);
295
296         // 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.
297         int decorations = style.textDecorationsInEffect();
298         if (decorations & TextDecorationUnderline)
299             paintDecoration(paintInfo.context(), TextDecorationUnderline, fragment);
300         if (decorations & TextDecorationOverline)
301             paintDecoration(paintInfo.context(), TextDecorationOverline, fragment);
302
303         auto paintOrder = style.svgStyle().paintTypesForPaintOrder();
304         for (unsigned i = 0; i < paintOrder.size(); ++i) {
305             switch (paintOrder.at(i)) {
306             case PaintTypeFill:
307                 if (!hasFill)
308                     continue;
309                 m_paintingResourceMode = ApplyToFillMode | ApplyToTextMode;
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                 paintText(paintInfo.context(), &style, selectionStyle, fragment, hasSelection, paintSelectedTextOnly);
317                 break;
318             case PaintTypeMarkers:
319                 continue;
320             }
321         }
322
323         // Spec: Line-through should be drawn after the text is filled and stroked; thus, the line-through is rendered on top of the text.
324         if (decorations & TextDecorationLineThrough)
325             paintDecoration(paintInfo.context(), TextDecorationLineThrough, fragment);
326
327         m_paintingResourceMode = ApplyToDefaultMode;
328     }
329
330     // Finally, paint the outline if any.
331     if (renderer().style().hasOutline() && is<RenderInline>(parentRenderer))
332         downcast<RenderInline>(parentRenderer).paintOutline(paintInfo, paintOffset);
333
334     ASSERT(!m_paintingResource);
335 }
336
337 bool SVGInlineTextBox::acquirePaintingResource(GraphicsContext*& context, float scalingFactor, RenderBoxModelObject& renderer, const RenderStyle* style)
338 {
339     ASSERT(scalingFactor);
340     ASSERT(style);
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     ASSERT(style);
393
394     TextRun run(StringView(renderer().text()).substring(fragment.characterOffset, fragment.length)
395                 , 0 /* xPos, only relevant with allowTabs=true */
396                 , 0 /* padding, only relevant for justified text, not relevant for SVG */
397                 , AllowTrailingExpansion
398                 , direction()
399                 , dirOverride() || style->rtlOrdering() == VisualOrder /* directionalOverride */);
400
401     // We handle letter & word spacing ourselves.
402     run.disableSpacing();
403
404     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
405     run.setCharactersLength(renderer().textLength() - fragment.characterOffset);
406     ASSERT(run.charactersLength() >= run.length());
407     return run;
408 }
409
410 bool SVGInlineTextBox::mapStartEndPositionsIntoFragmentCoordinates(const SVGTextFragment& fragment, int& startPosition, int& endPosition) const
411 {
412     if (startPosition >= endPosition)
413         return false;
414
415     int offset = static_cast<int>(fragment.characterOffset) - start();
416     int length = static_cast<int>(fragment.length);
417
418     if (startPosition >= offset + length || endPosition <= offset)
419         return false;
420
421     if (startPosition < offset)
422         startPosition = 0;
423     else
424         startPosition -= offset;
425
426     if (endPosition > offset + length)
427         endPosition = length;
428     else {
429         ASSERT(endPosition >= offset);
430         endPosition -= offset;
431     }
432
433     ASSERT_WITH_SECURITY_IMPLICATION(startPosition < endPosition);
434     return true;
435 }
436
437 static inline float positionOffsetForDecoration(TextDecoration decoration, const FontMetrics& fontMetrics, float thickness)
438 {
439     // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
440     // Compatible with Batik/Opera.
441     if (decoration == TextDecorationUnderline)
442         return fontMetrics.floatAscent() + thickness * 1.5f;
443     if (decoration == TextDecorationOverline)
444         return thickness;
445     if (decoration == TextDecorationLineThrough)
446         return fontMetrics.floatAscent() * 5 / 8.0f;
447
448     ASSERT_NOT_REACHED();
449     return 0.0f;
450 }
451
452 static inline float thicknessForDecoration(TextDecoration, const FontCascade& font)
453 {
454     // FIXME: For SVG Fonts we need to use the attributes defined in the <font-face> if specified.
455     // Compatible with Batik/Opera
456     return font.size() / 20.0f;
457 }
458
459 static inline RenderBoxModelObject& findRendererDefininingTextDecoration(InlineFlowBox* parentBox)
460 {
461     // Lookup first render object in parent hierarchy which has text-decoration set.
462     RenderBoxModelObject* renderer = nullptr;
463     while (parentBox) {
464         renderer = &parentBox->renderer();
465
466         if (renderer->style().textDecoration() != TextDecorationNone)
467             break;
468
469         parentBox = parentBox->parent();
470     }
471
472     ASSERT(renderer);
473     return *renderer;
474 }
475
476 void SVGInlineTextBox::paintDecoration(GraphicsContext& context, TextDecoration decoration, const SVGTextFragment& fragment)
477 {
478     if (renderer().style().textDecorationsInEffect() == TextDecorationNone)
479         return;
480
481     // Find out which render style defined the text-decoration, as its fill/stroke properties have to be used for drawing instead of ours.
482     auto& decorationRenderer = findRendererDefininingTextDecoration(parent());
483     const RenderStyle& decorationStyle = decorationRenderer.style();
484
485     if (decorationStyle.visibility() == HIDDEN)
486         return;
487
488     const SVGRenderStyle& svgDecorationStyle = decorationStyle.svgStyle();
489
490     bool hasDecorationFill = svgDecorationStyle.hasFill();
491     bool hasVisibleDecorationStroke = svgDecorationStyle.hasVisibleStroke();
492
493     if (hasDecorationFill) {
494         m_paintingResourceMode = ApplyToFillMode;
495         paintDecorationWithStyle(context, decoration, fragment, decorationRenderer);
496     }
497
498     if (hasVisibleDecorationStroke) {
499         m_paintingResourceMode = ApplyToStrokeMode;
500         paintDecorationWithStyle(context, decoration, fragment, decorationRenderer);
501     }
502 }
503
504 void SVGInlineTextBox::paintDecorationWithStyle(GraphicsContext& context, TextDecoration decoration, const SVGTextFragment& fragment, RenderBoxModelObject& decorationRenderer)
505 {
506     ASSERT(!m_paintingResource);
507     ASSERT(m_paintingResourceMode != ApplyToDefaultMode);
508
509     auto& decorationStyle = decorationRenderer.style();
510
511     float scalingFactor = 1;
512     FontCascade scaledFont;
513     RenderSVGInlineText::computeNewScaledFontForStyle(decorationRenderer, decorationStyle, scalingFactor, scaledFont);
514     ASSERT(scalingFactor);
515
516     // The initial y value refers to overline position.
517     float thickness = thicknessForDecoration(decoration, scaledFont);
518
519     if (fragment.width <= 0 && thickness <= 0)
520         return;
521
522     FloatPoint decorationOrigin(fragment.x, fragment.y);
523     float width = fragment.width;
524     const FontMetrics& scaledFontMetrics = scaledFont.fontMetrics();
525
526     GraphicsContextStateSaver stateSaver(context);
527     if (scalingFactor != 1) {
528         width *= scalingFactor;
529         decorationOrigin.scale(scalingFactor, scalingFactor);
530         context.scale(FloatSize(1 / scalingFactor, 1 / scalingFactor));
531     }
532
533     decorationOrigin.move(0, -scaledFontMetrics.floatAscent() + positionOffsetForDecoration(decoration, scaledFontMetrics, thickness));
534
535     Path path;
536     path.addRect(FloatRect(decorationOrigin, FloatSize(width, thickness)));
537
538     GraphicsContext* contextPtr = &context;
539     if (acquirePaintingResource(contextPtr, scalingFactor, decorationRenderer, &decorationStyle))
540         releasePaintingResource(contextPtr, &path);
541 }
542
543 void SVGInlineTextBox::paintTextWithShadows(GraphicsContext& context, const RenderStyle* style, TextRun& textRun, const SVGTextFragment& fragment, int startPosition, int endPosition)
544 {
545     float scalingFactor = renderer().scalingFactor();
546     ASSERT(scalingFactor);
547
548     const FontCascade& scaledFont = renderer().scaledFont();
549     const ShadowData* shadow = style->textShadow();
550
551     FloatPoint textOrigin(fragment.x, fragment.y);
552     FloatSize textSize(fragment.width, fragment.height);
553
554     if (scalingFactor != 1) {
555         textOrigin.scale(scalingFactor, scalingFactor);
556         textSize.scale(scalingFactor);
557     }
558
559     FloatRect shadowRect(FloatPoint(textOrigin.x(), textOrigin.y() - scaledFont.fontMetrics().floatAscent()), textSize);
560
561     GraphicsContext* usedContext = &context;
562     do {
563         if (!prepareGraphicsContextForTextPainting(usedContext, scalingFactor, style))
564             break;
565
566         {
567             ShadowApplier shadowApplier(*usedContext, shadow, shadowRect);
568
569             if (!shadowApplier.didSaveContext())
570                 usedContext->save();
571             usedContext->scale(FloatSize(1 / scalingFactor, 1 / scalingFactor));
572
573             scaledFont.drawText(*usedContext, textRun, textOrigin + shadowApplier.extraOffset(), startPosition, endPosition);
574
575             if (!shadowApplier.didSaveContext())
576                 usedContext->restore();
577         }
578
579         restoreGraphicsContextAfterTextPainting(usedContext);
580
581         if (!shadow)
582             break;
583
584         shadow = shadow->next();
585     } while (shadow);
586 }
587
588 void SVGInlineTextBox::paintText(GraphicsContext& context, const RenderStyle* style, const RenderStyle* selectionStyle, const SVGTextFragment& fragment, bool hasSelection, bool paintSelectedTextOnly)
589 {
590     ASSERT(style);
591     ASSERT(selectionStyle);
592
593     int startPosition = 0;
594     int endPosition = 0;
595     if (hasSelection) {
596         std::tie(startPosition, endPosition) = selectionStartEnd();
597         hasSelection = mapStartEndPositionsIntoFragmentCoordinates(fragment, startPosition, endPosition);
598     }
599
600     // Fast path if there is no selection, just draw the whole chunk part using the regular style
601     TextRun textRun = constructTextRun(style, fragment);
602     if (!hasSelection || startPosition >= endPosition) {
603         paintTextWithShadows(context, style, textRun, fragment, 0, fragment.length);
604         return;
605     }
606
607     // Eventually draw text using regular style until the start position of the selection
608     if (startPosition > 0 && !paintSelectedTextOnly)
609         paintTextWithShadows(context, style, textRun, fragment, 0, startPosition);
610
611     // Draw text using selection style from the start to the end position of the selection
612     if (style != selectionStyle)
613         SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, *selectionStyle);
614
615     paintTextWithShadows(context, selectionStyle, textRun, fragment, startPosition, endPosition);
616
617     if (style != selectionStyle)
618         SVGResourcesCache::clientStyleChanged(parent()->renderer(), StyleDifferenceRepaint, *style);
619
620     // Eventually draw text using regular style from the end position of the selection to the end of the current chunk part
621     if (endPosition < static_cast<int>(fragment.length) && !paintSelectedTextOnly)
622         paintTextWithShadows(context, style, textRun, fragment, endPosition, fragment.length);
623 }
624
625 FloatRect SVGInlineTextBox::calculateBoundaries() const
626 {
627     FloatRect textRect;
628
629     float scalingFactor = renderer().scalingFactor();
630     ASSERT(scalingFactor);
631
632     float baseline = renderer().scaledFont().fontMetrics().floatAscent() / scalingFactor;
633
634     AffineTransform fragmentTransform;
635     unsigned textFragmentsSize = m_textFragments.size();
636     for (unsigned i = 0; i < textFragmentsSize; ++i) {
637         const SVGTextFragment& fragment = m_textFragments.at(i);
638         FloatRect fragmentRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height);
639         fragment.buildFragmentTransform(fragmentTransform);
640         if (!fragmentTransform.isIdentity())
641             fragmentRect = fragmentTransform.mapRect(fragmentRect);
642
643         textRect.unite(fragmentRect);
644     }
645
646     return textRect;
647 }
648
649 bool SVGInlineTextBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit, LayoutUnit, HitTestAction)
650 {
651     // FIXME: integrate with InlineTextBox::nodeAtPoint better.
652     ASSERT(!isLineBreak());
653
654     PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING, request, renderer().style().pointerEvents());
655     bool isVisible = renderer().style().visibility() == VISIBLE;
656     if (isVisible || !hitRules.requireVisible) {
657         if ((hitRules.canHitStroke && (renderer().style().svgStyle().hasStroke() || !hitRules.requireStroke))
658             || (hitRules.canHitFill && (renderer().style().svgStyle().hasFill() || !hitRules.requireFill))) {
659             FloatPoint boxOrigin(x(), y());
660             boxOrigin.moveBy(accumulatedOffset);
661             FloatRect rect(boxOrigin, size());
662             if (locationInContainer.intersects(rect)) {
663
664                 float scalingFactor = renderer().scalingFactor();
665                 ASSERT(scalingFactor);
666                 
667                 float baseline = renderer().scaledFont().fontMetrics().floatAscent() / scalingFactor;
668
669                 AffineTransform fragmentTransform;
670                 for (auto& fragment : m_textFragments) {
671                     FloatQuad fragmentQuad(FloatRect(fragment.x, fragment.y - baseline, fragment.width, fragment.height));
672                     fragment.buildFragmentTransform(fragmentTransform);
673                     if (!fragmentTransform.isIdentity())
674                         fragmentQuad = fragmentTransform.mapQuad(fragmentQuad);
675                     
676                     if (fragmentQuad.containsPoint(locationInContainer.point())) {
677                         renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
678                         if (!result.addNodeToRectBasedTestResult(&renderer().textNode(), request, locationInContainer, rect))
679                             return true;
680                     }
681                 }
682              }
683         }
684     }
685     return false;
686 }
687
688 } // namespace WebCore