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