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