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