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