Source/WebCore/platform/graphics/GraphicsContext.cpp

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "GraphicsContext.h"
  28
  29 #include "BidiResolver.h"
  30 #include "Font.h"
  31 #include "Generator.h"
  32 #include "ImageBuffer.h"
  33 #include "IntRect.h"
  34 #include "RoundedIntRect.h"
  35 #include "TextRun.h"
  36
  37 using namespace std;
  38
  39 namespace WebCore {
  40
  41 class TextRunIterator {
  42 public:
  43     TextRunIterator()
  44         : m_textRun(0)
  45         , m_offset(0)
  46     {
  47     }
  48
  49     TextRunIterator(const TextRun* textRun, unsigned offset)
  50         : m_textRun(textRun)
  51         , m_offset(offset)
  52     {
  53     }
  54
  55     TextRunIterator(const TextRunIterator& other)
  56         : m_textRun(other.m_textRun)
  57         , m_offset(other.m_offset)
  58     {
  59     }
  60
  61     unsigned offset() const { return m_offset; }
  62     void increment() { m_offset++; }
  63     bool atEnd() const { return !m_textRun || m_offset >= m_textRun->length(); }
  64     UChar current() const { return (*m_textRun)[m_offset]; }
  65     WTF::Unicode::Direction direction() const { return atEnd() ? WTF::Unicode::OtherNeutral : WTF::Unicode::direction(current()); }
  66
  67     bool operator==(const TextRunIterator& other)
  68     {
  69         return m_offset == other.m_offset && m_textRun == other.m_textRun;
  70     }
  71
  72     bool operator!=(const TextRunIterator& other) { return !operator==(other); }
  73
  74 private:
  75     const TextRun* m_textRun;
  76     int m_offset;
  77 };
  78
  79 GraphicsContext::GraphicsContext(PlatformGraphicsContext* platformGraphicsContext)
  80     : m_updatingControlTints(false)
  81 {
  82     platformInit(platformGraphicsContext);
  83 }
  84
  85 GraphicsContext::~GraphicsContext()
  86 {
  87     platformDestroy();
  88 }
  89
  90 void GraphicsContext::save()
  91 {
  92     if (paintingDisabled())
  93         return;
  94
  95     m_stack.append(m_state);
  96
  97     savePlatformState();
  98 }
  99
 100 void GraphicsContext::restore()
 101 {
 102     if (paintingDisabled())
 103         return;
 104
 105     if (m_stack.isEmpty()) {
 106         LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
 107         return;
 108     }
 109     m_state = m_stack.last();
 110     m_stack.removeLast();
 111
 112     restorePlatformState();
 113 }
 114
 115 void GraphicsContext::setStrokeThickness(float thickness)
 116 {
 117     m_state.strokeThickness = thickness;
 118     setPlatformStrokeThickness(thickness);
 119 }
 120
 121 void GraphicsContext::setStrokeStyle(StrokeStyle style)
 122 {
 123     m_state.strokeStyle = style;
 124     setPlatformStrokeStyle(style);
 125 }
 126
 127 void GraphicsContext::setStrokeColor(const Color& color, ColorSpace colorSpace)
 128 {
 129     m_state.strokeColor = color;
 130     m_state.strokeColorSpace = colorSpace;
 131     m_state.strokeGradient.clear();
 132     m_state.strokePattern.clear();
 133     setPlatformStrokeColor(color, colorSpace);
 134 }
 135
 136 void GraphicsContext::setShadow(const FloatSize& offset, float blur, const Color& color, ColorSpace colorSpace)
 137 {
 138     m_state.shadowOffset = offset;
 139     m_state.shadowBlur = blur;
 140     m_state.shadowColor = color;
 141     m_state.shadowColorSpace = colorSpace;
 142     setPlatformShadow(offset, blur, color, colorSpace);
 143 }
 144
 145 void GraphicsContext::setLegacyShadow(const FloatSize& offset, float blur, const Color& color, ColorSpace colorSpace)
 146 {
 147     m_state.shadowOffset = offset;
 148     m_state.shadowBlur = blur;
 149     m_state.shadowColor = color;
 150     m_state.shadowColorSpace = colorSpace;
 151 #if USE(CG)
 152     m_state.shadowsUseLegacyRadius = true;
 153 #endif
 154     setPlatformShadow(offset, blur, color, colorSpace);
 155 }
 156
 157 void GraphicsContext::clearShadow()
 158 {
 159     m_state.shadowOffset = FloatSize();
 160     m_state.shadowBlur = 0;
 161     m_state.shadowColor = Color();
 162     m_state.shadowColorSpace = ColorSpaceDeviceRGB;
 163     clearPlatformShadow();
 164 }
 165
 166 bool GraphicsContext::hasShadow() const
 167 {
 168     return m_state.shadowColor.isValid() && m_state.shadowColor.alpha()
 169            && (m_state.shadowBlur || m_state.shadowOffset.width() || m_state.shadowOffset.height());
 170 }
 171
 172 bool GraphicsContext::getShadow(FloatSize& offset, float& blur, Color& color, ColorSpace& colorSpace) const
 173 {
 174     offset = m_state.shadowOffset;
 175     blur = m_state.shadowBlur;
 176     color = m_state.shadowColor;
 177     colorSpace = m_state.shadowColorSpace;
 178
 179     return hasShadow();
 180 }
 181
 182 float GraphicsContext::strokeThickness() const
 183 {
 184     return m_state.strokeThickness;
 185 }
 186
 187 StrokeStyle GraphicsContext::strokeStyle() const
 188 {
 189     return m_state.strokeStyle;
 190 }
 191
 192 Color GraphicsContext::strokeColor() const
 193 {
 194     return m_state.strokeColor;
 195 }
 196
 197 ColorSpace GraphicsContext::strokeColorSpace() const
 198 {
 199     return m_state.strokeColorSpace;
 200 }
 201
 202 WindRule GraphicsContext::fillRule() const
 203 {
 204     return m_state.fillRule;
 205 }
 206
 207 void GraphicsContext::setFillRule(WindRule fillRule)
 208 {
 209     m_state.fillRule = fillRule;
 210 }
 211
 212 void GraphicsContext::setFillColor(const Color& color, ColorSpace colorSpace)
 213 {
 214     m_state.fillColor = color;
 215     m_state.fillColorSpace = colorSpace;
 216     m_state.fillGradient.clear();
 217     m_state.fillPattern.clear();
 218     setPlatformFillColor(color, colorSpace);
 219 }
 220
 221 Color GraphicsContext::fillColor() const
 222 {
 223     return m_state.fillColor;
 224 }
 225
 226 ColorSpace GraphicsContext::fillColorSpace() const
 227 {
 228     return m_state.fillColorSpace;
 229 }
 230
 231 void GraphicsContext::setShouldAntialias(bool b)
 232 {
 233     m_state.shouldAntialias = b;
 234     setPlatformShouldAntialias(b);
 235 }
 236
 237 bool GraphicsContext::shouldAntialias() const
 238 {
 239     return m_state.shouldAntialias;
 240 }
 241
 242 void GraphicsContext::setShouldSmoothFonts(bool b)
 243 {
 244     m_state.shouldSmoothFonts = b;
 245     setPlatformShouldSmoothFonts(b);
 246 }
 247
 248 bool GraphicsContext::shouldSmoothFonts() const
 249 {
 250     return m_state.shouldSmoothFonts;
 251 }
 252
 253 const GraphicsContextState& GraphicsContext::state() const
 254 {
 255     return m_state;
 256 }
 257
 258 void GraphicsContext::setStrokePattern(PassRefPtr<Pattern> pattern)
 259 {
 260     ASSERT(pattern);
 261     if (!pattern) {
 262         setStrokeColor(Color::black, ColorSpaceDeviceRGB);
 263         return;
 264     }
 265     m_state.strokeGradient.clear();
 266     m_state.strokePattern = pattern;
 267     setPlatformStrokePattern(m_state.strokePattern.get());
 268 }
 269
 270 void GraphicsContext::setFillPattern(PassRefPtr<Pattern> pattern)
 271 {
 272     ASSERT(pattern);
 273     if (!pattern) {
 274         setFillColor(Color::black, ColorSpaceDeviceRGB);
 275         return;
 276     }
 277     m_state.fillGradient.clear();
 278     m_state.fillPattern = pattern;
 279     setPlatformFillPattern(m_state.fillPattern.get());
 280 }
 281
 282 void GraphicsContext::setStrokeGradient(PassRefPtr<Gradient> gradient)
 283 {
 284     ASSERT(gradient);
 285     if (!gradient) {
 286         setStrokeColor(Color::black, ColorSpaceDeviceRGB);
 287         return;
 288     }
 289     m_state.strokeGradient = gradient;
 290     m_state.strokePattern.clear();
 291     setPlatformStrokeGradient(m_state.strokeGradient.get());
 292 }
 293
 294 void GraphicsContext::setFillGradient(PassRefPtr<Gradient> gradient)
 295 {
 296     ASSERT(gradient);
 297     if (!gradient) {
 298         setFillColor(Color::black, ColorSpaceDeviceRGB);
 299         return;
 300     }
 301     m_state.fillGradient = gradient;
 302     m_state.fillPattern.clear();
 303     setPlatformFillGradient(m_state.fillGradient.get());
 304 }
 305
 306 Gradient* GraphicsContext::fillGradient() const
 307 {
 308     return m_state.fillGradient.get();
 309 }
 310
 311 Gradient* GraphicsContext::strokeGradient() const
 312 {
 313     return m_state.strokeGradient.get();
 314 }
 315
 316 Pattern* GraphicsContext::fillPattern() const
 317 {
 318     return m_state.fillPattern.get();
 319 }
 320
 321 Pattern* GraphicsContext::strokePattern() const
 322 {
 323     return m_state.strokePattern.get();
 324 }
 325
 326 void GraphicsContext::setShadowsIgnoreTransforms(bool ignoreTransforms)
 327 {
 328     m_state.shadowsIgnoreTransforms = ignoreTransforms;
 329 }
 330
 331 bool GraphicsContext::shadowsIgnoreTransforms() const
 332 {
 333     return m_state.shadowsIgnoreTransforms;
 334 }
 335
 336 bool GraphicsContext::updatingControlTints() const
 337 {
 338     return m_updatingControlTints;
 339 }
 340
 341 void GraphicsContext::setUpdatingControlTints(bool b)
 342 {
 343     setPaintingDisabled(b);
 344     m_updatingControlTints = b;
 345 }
 346
 347 void GraphicsContext::setPaintingDisabled(bool f)
 348 {
 349     m_state.paintingDisabled = f;
 350 }
 351
 352 bool GraphicsContext::paintingDisabled() const
 353 {
 354     return m_state.paintingDisabled;
 355 }
 356
 357 void GraphicsContext::drawImage(Image* image, ColorSpace styleColorSpace, const IntPoint& p, CompositeOperator op)
 358 {
 359     drawImage(image, styleColorSpace, p, IntRect(0, 0, -1, -1), op);
 360 }
 361
 362 void GraphicsContext::drawImage(Image* image, ColorSpace styleColorSpace, const IntRect& r, CompositeOperator op, bool useLowQualityScale)
 363 {
 364     drawImage(image, styleColorSpace, r, IntRect(0, 0, -1, -1), op, useLowQualityScale);
 365 }
 366
 367 void GraphicsContext::drawImage(Image* image, ColorSpace styleColorSpace, const IntPoint& dest, const IntRect& srcRect, CompositeOperator op)
 368 {
 369     drawImage(image, styleColorSpace, IntRect(dest, srcRect.size()), srcRect, op);
 370 }
 371
 372 void GraphicsContext::drawImage(Image* image, ColorSpace styleColorSpace, const IntRect& dest, const IntRect& srcRect, CompositeOperator op, bool useLowQualityScale)
 373 {
 374     drawImage(image, styleColorSpace, FloatRect(dest), srcRect, op, useLowQualityScale);
 375 }
 376
 377 #if !OS(WINCE) || PLATFORM(QT)
 378 void GraphicsContext::drawText(const Font& font, const TextRun& run, const FloatPoint& point, int from, int to)
 379 {
 380     if (paintingDisabled())
 381         return;
 382
 383     font.drawText(this, run, point, from, to);
 384 }
 385 #endif
 386
 387 void GraphicsContext::drawEmphasisMarks(const Font& font, const TextRun& run, const AtomicString& mark, const FloatPoint& point, int from, int to)
 388 {
 389     if (paintingDisabled())
 390         return;
 391
 392     font.drawEmphasisMarks(this, run, mark, point, from, to);
 393 }
 394
 395 void GraphicsContext::drawBidiText(const Font& font, const TextRun& run, const FloatPoint& point)
 396 {
 397     if (paintingDisabled())
 398         return;
 399
 400     // FIXME: This ownership should be reversed. We should pass BidiRunList
 401     // to BidiResolver in createBidiRunsForLine.
 402     BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
 403     BidiRunList<BidiCharacterRun>& bidiRuns = bidiResolver.runs();
 404
 405     WTF::Unicode::Direction paragraphDirection = run.ltr() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
 406
 407     bidiResolver.setStatus(BidiStatus(paragraphDirection, paragraphDirection, paragraphDirection, BidiContext::create(run.ltr() ? 0 : 1, paragraphDirection, run.directionalOverride())));
 408
 409     bidiResolver.setPosition(TextRunIterator(&run, 0));
 410     bidiResolver.createBidiRunsForLine(TextRunIterator(&run, run.length()));
 411
 412     if (!bidiRuns.runCount())
 413         return;
 414
 415     FloatPoint currPoint = point;
 416     BidiCharacterRun* bidiRun = bidiRuns.firstRun();
 417     while (bidiRun) {
 418
 419         TextRun subrun = run;
 420         subrun.setText(run.data(bidiRun->start()), bidiRun->stop() - bidiRun->start());
 421         subrun.setRTL(bidiRun->level() % 2);
 422         subrun.setDirectionalOverride(bidiRun->dirOverride(false));
 423
 424         font.drawText(this, subrun, currPoint);
 425
 426         bidiRun = bidiRun->next();
 427         // FIXME: Have Font::drawText return the width of what it drew so that we don't have to re-measure here.
 428         if (bidiRun)
 429             currPoint.move(font.width(subrun), 0);
 430     }
 431
 432     bidiRuns.deleteRuns();
 433 }
 434
 435 void GraphicsContext::drawHighlightForText(const Font& font, const TextRun& run, const FloatPoint& point, int h, const Color& backgroundColor, ColorSpace colorSpace, int from, int to)
 436 {
 437     if (paintingDisabled())
 438         return;
 439
 440     fillRect(font.selectionRectForText(run, point, h, from, to), backgroundColor, colorSpace);
 441 }
 442
 443 void GraphicsContext::drawImage(Image* image, ColorSpace styleColorSpace, const FloatRect& dest, const FloatRect& src, CompositeOperator op, bool useLowQualityScale)
 444 {
 445     if (paintingDisabled() || !image)
 446         return;
 447
 448     float tsw = src.width();
 449     float tsh = src.height();
 450     float tw = dest.width();
 451     float th = dest.height();
 452
 453     if (tsw == -1)
 454         tsw = image->width();
 455     if (tsh == -1)
 456         tsh = image->height();
 457
 458     if (tw == -1)
 459         tw = image->width();
 460     if (th == -1)
 461         th = image->height();
 462
 463     if (useLowQualityScale) {
 464         InterpolationQuality previousInterpolationQuality = imageInterpolationQuality();
 465         // FIXME: Should be InterpolationLow
 466         setImageInterpolationQuality(InterpolationNone);
 467         image->draw(this, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), styleColorSpace, op);
 468         setImageInterpolationQuality(previousInterpolationQuality);
 469     } else
 470         image->draw(this, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), styleColorSpace, op);
 471 }
 472
 473 void GraphicsContext::drawTiledImage(Image* image, ColorSpace styleColorSpace, const IntRect& rect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op, bool useLowQualityScale)
 474 {
 475     if (paintingDisabled() || !image)
 476         return;
 477
 478     if (useLowQualityScale) {
 479         InterpolationQuality previousInterpolationQuality = imageInterpolationQuality();
 480         setImageInterpolationQuality(InterpolationLow);
 481         image->drawTiled(this, rect, srcPoint, tileSize, styleColorSpace, op);
 482         setImageInterpolationQuality(previousInterpolationQuality);
 483     } else
 484         image->drawTiled(this, rect, srcPoint, tileSize, styleColorSpace, op);
 485 }
 486
 487 void GraphicsContext::drawTiledImage(Image* image, ColorSpace styleColorSpace, const IntRect& dest, const IntRect& srcRect, Image::TileRule hRule, Image::TileRule vRule, CompositeOperator op, bool useLowQualityScale)
 488 {
 489     if (paintingDisabled() || !image)
 490         return;
 491
 492     if (hRule == Image::StretchTile && vRule == Image::StretchTile) {
 493         // Just do a scale.
 494         drawImage(image, styleColorSpace, dest, srcRect, op);
 495         return;
 496     }
 497
 498     if (useLowQualityScale) {
 499         InterpolationQuality previousInterpolationQuality = imageInterpolationQuality();
 500         setImageInterpolationQuality(InterpolationLow);
 501         image->drawTiled(this, dest, srcRect, hRule, vRule, styleColorSpace, op);
 502         setImageInterpolationQuality(previousInterpolationQuality);
 503     } else
 504         image->drawTiled(this, dest, srcRect, hRule, vRule, styleColorSpace, op);
 505 }
 506
 507 void GraphicsContext::drawImageBuffer(ImageBuffer* image, ColorSpace styleColorSpace, const IntPoint& p, CompositeOperator op)
 508 {
 509     drawImageBuffer(image, styleColorSpace, p, IntRect(0, 0, -1, -1), op);
 510 }
 511
 512 void GraphicsContext::drawImageBuffer(ImageBuffer* image, ColorSpace styleColorSpace, const IntRect& r, CompositeOperator op, bool useLowQualityScale)
 513 {
 514     drawImageBuffer(image, styleColorSpace, r, IntRect(0, 0, -1, -1), op, useLowQualityScale);
 515 }
 516
 517 void GraphicsContext::drawImageBuffer(ImageBuffer* image, ColorSpace styleColorSpace, const IntPoint& dest, const IntRect& srcRect, CompositeOperator op)
 518 {
 519     drawImageBuffer(image, styleColorSpace, IntRect(dest, srcRect.size()), srcRect, op);
 520 }
 521
 522 void GraphicsContext::drawImageBuffer(ImageBuffer* image, ColorSpace styleColorSpace, const IntRect& dest, const IntRect& srcRect, CompositeOperator op, bool useLowQualityScale)
 523 {
 524     drawImageBuffer(image, styleColorSpace, FloatRect(dest), srcRect, op, useLowQualityScale);
 525 }
 526
 527 void GraphicsContext::drawImageBuffer(ImageBuffer* image, ColorSpace styleColorSpace, const FloatRect& dest, const FloatRect& src, CompositeOperator op, bool useLowQualityScale)
 528 {
 529     if (paintingDisabled() || !image)
 530         return;
 531
 532     float tsw = src.width();
 533     float tsh = src.height();
 534     float tw = dest.width();
 535     float th = dest.height();
 536
 537     if (tsw == -1)
 538         tsw = image->width();
 539     if (tsh == -1)
 540         tsh = image->height();
 541
 542     if (tw == -1)
 543         tw = image->width();
 544     if (th == -1)
 545         th = image->height();
 546
 547     if (useLowQualityScale) {
 548         InterpolationQuality previousInterpolationQuality = imageInterpolationQuality();
 549         // FIXME: Should be InterpolationLow
 550         setImageInterpolationQuality(InterpolationNone);
 551         image->draw(this, styleColorSpace, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), op, useLowQualityScale);
 552         setImageInterpolationQuality(previousInterpolationQuality);
 553     } else
 554         image->draw(this, styleColorSpace, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), op, useLowQualityScale);
 555 }
 556
 557 #if !PLATFORM(QT)
 558 void GraphicsContext::clip(const IntRect& rect)
 559 {
 560     clip(FloatRect(rect));
 561 }
 562 #endif
 563
 564 void GraphicsContext::addRoundedRectClip(const RoundedIntRect& rect)
 565 {
 566     if (paintingDisabled())
 567         return;
 568
 569     Path path;
 570     path.addRoundedRect(rect);
 571     clip(path);
 572 }
 573
 574 void GraphicsContext::clipOutRoundedRect(const RoundedIntRect& rect)
 575 {
 576     if (paintingDisabled())
 577         return;
 578
 579     Path path;
 580     path.addRoundedRect(rect);
 581     clipOut(path);
 582 }
 583
 584 void GraphicsContext::clipToImageBuffer(ImageBuffer* buffer, const FloatRect& rect)
 585 {
 586     if (paintingDisabled())
 587         return;
 588     buffer->clip(this, rect);
 589 }
 590
 591 #if !USE(CG)
 592 IntRect GraphicsContext::clipBounds() const
 593 {
 594     ASSERT_NOT_REACHED();
 595     return IntRect();
 596 }
 597 #endif
 598
 599 TextDrawingModeFlags GraphicsContext::textDrawingMode() const
 600 {
 601     return m_state.textDrawingMode;
 602 }
 603
 604 void GraphicsContext::setTextDrawingMode(TextDrawingModeFlags mode)
 605 {
 606     m_state.textDrawingMode = mode;
 607     if (paintingDisabled())
 608         return;
 609     setPlatformTextDrawingMode(mode);
 610 }
 611
 612 void GraphicsContext::fillRect(const FloatRect& rect, Generator& generator)
 613 {
 614     if (paintingDisabled())
 615         return;
 616     generator.fill(this, rect);
 617 }
 618
 619 void GraphicsContext::fillRoundedRect(const RoundedIntRect& rect, const Color& color, ColorSpace colorSpace)
 620 {
 621     fillRoundedRect(rect.rect(), rect.radii().topLeft(), rect.radii().topRight(), rect.radii().bottomLeft(), rect.radii().bottomRight(), color, colorSpace);
 622 }
 623
 624 #if !USE(CG)
 625 void GraphicsContext::fillRectWithRoundedHole(const IntRect& rect, const RoundedIntRect& roundedHoleRect, const Color& color, ColorSpace colorSpace)
 626 {
 627     if (paintingDisabled())
 628         return;
 629
 630     Path path;
 631     path.addRect(rect);
 632
 633     if (!roundedHoleRect.radii().isZero())
 634         path.addRoundedRect(roundedHoleRect);
 635     else
 636         path.addRect(roundedHoleRect.rect());
 637
 638     WindRule oldFillRule = fillRule();
 639     Color oldFillColor = fillColor();
 640     ColorSpace oldFillColorSpace = fillColorSpace();
 641
 642     setFillRule(RULE_EVENODD);
 643     setFillColor(color, colorSpace);
 644
 645     fillPath(path);
 646
 647     setFillRule(oldFillRule);
 648     setFillColor(oldFillColor, oldFillColorSpace);
 649 }
 650 #endif
 651
 652 void GraphicsContext::setCompositeOperation(CompositeOperator compositeOperation)
 653 {
 654     m_state.compositeOperator = compositeOperation;
 655     setPlatformCompositeOperation(compositeOperation);
 656 }
 657
 658 CompositeOperator GraphicsContext::compositeOperation() const
 659 {
 660     return m_state.compositeOperator;
 661 }
 662
 663 #if !(USE(SKIA) && !PLATFORM(ANDROID))
 664 void GraphicsContext::setPlatformFillGradient(Gradient*)
 665 {
 666 }
 667
 668 void GraphicsContext::setPlatformFillPattern(Pattern*)
 669 {
 670 }
 671
 672 void GraphicsContext::setPlatformStrokeGradient(Gradient*)
 673 {
 674 }
 675
 676 void GraphicsContext::setPlatformStrokePattern(Pattern*)
 677 {
 678 }
 679 #endif
 680
 681 #if !USE(CG) && !(USE(SKIA) && !PLATFORM(ANDROID))
 682 // Implement this if you want to go ahead and push the drawing mode into your native context
 683 // immediately.
 684 void GraphicsContext::setPlatformTextDrawingMode(TextDrawingModeFlags mode)
 685 {
 686 }
 687 #endif
 688
 689 #if !PLATFORM(QT) && !USE(CAIRO) && !(USE(SKIA) && !PLATFORM(ANDROID)) && !PLATFORM(HAIKU) && !PLATFORM(OPENVG)
 690 void GraphicsContext::setPlatformStrokeStyle(StrokeStyle)
 691 {
 692 }
 693 #endif
 694
 695 #if !USE(CG)
 696 void GraphicsContext::setPlatformShouldSmoothFonts(bool)
 697 {
 698 }
 699 #endif
 700
 701 #if !USE(SKIA)
 702 void GraphicsContext::setSharedGraphicsContext3D(SharedGraphicsContext3D*, DrawingBuffer*, const IntSize&)
 703 {
 704 }
 705
 706 void GraphicsContext::syncSoftwareCanvas()
 707 {
 708 }
 709
 710 void GraphicsContext::markDirtyRect(const IntRect&)
 711 {
 712 }
 713 #endif
 714
 715
 716 void GraphicsContext::adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle penStyle)
 717 {
 718     // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic
 719     // works out.  For example, with a border width of 3, WebKit will pass us (y1+y2)/2, e.g.,
 720     // (50+53)/2 = 103/2 = 51 when we want 51.5.  It is always true that an even width gave
 721     // us a perfect position, but an odd width gave us a position that is off by exactly 0.5.
 722     if (penStyle == DottedStroke || penStyle == DashedStroke) {
 723         if (p1.x() == p2.x()) {
 724             p1.setY(p1.y() + strokeWidth);
 725             p2.setY(p2.y() - strokeWidth);
 726         } else {
 727             p1.setX(p1.x() + strokeWidth);
 728             p2.setX(p2.x() - strokeWidth);
 729         }
 730     }
 731
 732     if (static_cast<int>(strokeWidth) % 2) { //odd
 733         if (p1.x() == p2.x()) {
 734             // We're a vertical line.  Adjust our x.
 735             p1.setX(p1.x() + 0.5f);
 736             p2.setX(p2.x() + 0.5f);
 737         } else {
 738             // We're a horizontal line. Adjust our y.
 739             p1.setY(p1.y() + 0.5f);
 740             p2.setY(p2.y() + 0.5f);
 741         }
 742     }
 743 }
 744
 745 }