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