WebCore/platform/graphics/cg/GraphicsContextCG.cpp

   1 /*
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2007 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 COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #define _USE_MATH_DEFINES 1
  27 #include "config.h"
  28 #include "GraphicsContext.h"
  29
  30 #if PLATFORM(CG)
  31
  32 #include "AffineTransform.h"
  33 #include "GraphicsContextPlatformPrivate.h"
  34 #include "KURL.h"
  35 #include "Path.h"
  36 #include <CoreGraphics/CGPDFContext.h>
  37 #include <wtf/MathExtras.h>
  38
  39 using namespace std;
  40
  41 namespace WebCore {
  42
  43 static void setCGFillColor(CGContextRef context, const Color& color)
  44 {
  45     CGFloat red, green, blue, alpha;
  46     color.getRGBA(red, green, blue, alpha);
  47     CGContextSetRGBFillColor(context, red, green, blue, alpha);
  48 }
  49
  50 static void setCGStrokeColor(CGContextRef context, const Color& color)
  51 {
  52     CGFloat red, green, blue, alpha;
  53     color.getRGBA(red, green, blue, alpha);
  54     CGContextSetRGBStrokeColor(context, red, green, blue, alpha);
  55 }
  56
  57 GraphicsContext::GraphicsContext(CGContextRef cgContext)
  58     : m_common(createGraphicsContextPrivate())
  59     , m_data(new GraphicsContextPlatformPrivate(cgContext))
  60 {
  61     setPaintingDisabled(!cgContext);
  62     if (cgContext) {
  63         // Make sure the context starts in sync with our state.
  64         setPlatformFillColor(fillColor());
  65         setPlatformStrokeColor(strokeColor());
  66     }
  67 }
  68
  69 GraphicsContext::~GraphicsContext()
  70 {
  71     destroyGraphicsContextPrivate(m_common);
  72     delete m_data;
  73 }
  74
  75 CGContextRef GraphicsContext::platformContext() const
  76 {
  77     ASSERT(!paintingDisabled());
  78     ASSERT(m_data->m_cgContext);
  79     return m_data->m_cgContext;
  80 }
  81
  82 void GraphicsContext::savePlatformState()
  83 {
  84     // Note: Do not use this function within this class implementation, since we want to avoid the extra
  85     // save of the secondary context (in GraphicsContextPlatformPrivate.h).
  86     CGContextSaveGState(platformContext());
  87     m_data->save();
  88 }
  89
  90 void GraphicsContext::restorePlatformState()
  91 {
  92     // Note: Do not use this function within this class implementation, since we want to avoid the extra
  93     // restore of the secondary context (in GraphicsContextPlatformPrivate.h).
  94     CGContextRestoreGState(platformContext());
  95     m_data->restore();
  96     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
  97 }
  98
  99 // Draws a filled rectangle with a stroked border.
 100 void GraphicsContext::drawRect(const IntRect& rect)
 101 {
 102     if (paintingDisabled())
 103         return;
 104
 105     CGContextRef context = platformContext();
 106
 107     if (fillColor().alpha())
 108         CGContextFillRect(context, rect);
 109
 110     if (strokeStyle() != NoStroke && strokeColor().alpha()) {
 111         // We do a fill of four rects to simulate the stroke of a border.
 112         Color oldFillColor = fillColor();
 113         if (oldFillColor != strokeColor())
 114             setCGFillColor(context, strokeColor());
 115         CGRect rects[4] = {
 116             FloatRect(rect.x(), rect.y(), rect.width(), 1),
 117             FloatRect(rect.x(), rect.bottom() - 1, rect.width(), 1),
 118             FloatRect(rect.x(), rect.y() + 1, 1, rect.height() - 2),
 119             FloatRect(rect.right() - 1, rect.y() + 1, 1, rect.height() - 2)
 120         };
 121         CGContextFillRects(context, rects, 4);
 122         if (oldFillColor != strokeColor())
 123             setCGFillColor(context, oldFillColor);
 124     }
 125 }
 126
 127 // This is only used to draw borders.
 128 void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
 129 {
 130     if (paintingDisabled())
 131         return;
 132
 133     if (strokeStyle() == NoStroke || !strokeColor().alpha())
 134         return;
 135
 136     float width = strokeThickness();
 137
 138     FloatPoint p1 = point1;
 139     FloatPoint p2 = point2;
 140     bool isVerticalLine = (p1.x() == p2.x());
 141
 142     // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic
 143     // works out.  For example, with a border width of 3, KHTML will pass us (y1+y2)/2, e.g.,
 144     // (50+53)/2 = 103/2 = 51 when we want 51.5.  It is always true that an even width gave
 145     // us a perfect position, but an odd width gave us a position that is off by exactly 0.5.
 146     if (strokeStyle() == DottedStroke || strokeStyle() == DashedStroke) {
 147         if (isVerticalLine) {
 148             p1.move(0, width);
 149             p2.move(0, -width);
 150         } else {
 151             p1.move(width, 0);
 152             p2.move(-width, 0);
 153         }
 154     }
 155
 156     if (((int)width) % 2) {
 157         if (isVerticalLine) {
 158             // We're a vertical line.  Adjust our x.
 159             p1.move(0.5f, 0.0f);
 160             p2.move(0.5f, 0.0f);
 161         } else {
 162             // We're a horizontal line. Adjust our y.
 163             p1.move(0.0f, 0.5f);
 164             p2.move(0.0f, 0.5f);
 165         }
 166     }
 167
 168     int patWidth = 0;
 169     switch (strokeStyle()) {
 170         case NoStroke:
 171         case SolidStroke:
 172             break;
 173         case DottedStroke:
 174             patWidth = (int)width;
 175             break;
 176         case DashedStroke:
 177             patWidth = 3 * (int)width;
 178             break;
 179     }
 180
 181     CGContextRef context = platformContext();
 182     CGContextSaveGState(context);
 183
 184     CGContextSetShouldAntialias(context, false);
 185
 186     if (patWidth) {
 187         // Do a rect fill of our endpoints.  This ensures we always have the
 188         // appearance of being a border.  We then draw the actual dotted/dashed line.
 189         setCGFillColor(context, strokeColor());  // The save/restore make it safe to mutate the fill color here without setting it back to the old color.
 190         if (isVerticalLine) {
 191             CGContextFillRect(context, FloatRect(p1.x() - width / 2, p1.y() - width, width, width));
 192             CGContextFillRect(context, FloatRect(p2.x() - width / 2, p2.y(), width, width));
 193         } else {
 194             CGContextFillRect(context, FloatRect(p1.x() - width, p1.y() - width / 2, width, width));
 195             CGContextFillRect(context, FloatRect(p2.x(), p2.y() - width / 2, width, width));
 196         }
 197
 198         // Example: 80 pixels with a width of 30 pixels.
 199         // Remainder is 20.  The maximum pixels of line we could paint
 200         // will be 50 pixels.
 201         int distance = (isVerticalLine ? (point2.y() - point1.y()) : (point2.x() - point1.x())) - 2*(int)width;
 202         int remainder = distance % patWidth;
 203         int coverage = distance - remainder;
 204         int numSegments = coverage / patWidth;
 205
 206         float patternOffset = 0.0f;
 207         // Special case 1px dotted borders for speed.
 208         if (patWidth == 1)
 209             patternOffset = 1.0f;
 210         else {
 211             bool evenNumberOfSegments = numSegments % 2 == 0;
 212             if (remainder)
 213                 evenNumberOfSegments = !evenNumberOfSegments;
 214             if (evenNumberOfSegments) {
 215                 if (remainder) {
 216                     patternOffset += patWidth - remainder;
 217                     patternOffset += remainder / 2;
 218                 } else
 219                     patternOffset = patWidth / 2;
 220             } else {
 221                 if (remainder)
 222                     patternOffset = (patWidth - remainder)/2;
 223             }
 224         }
 225
 226         const CGFloat dottedLine[2] = { patWidth, patWidth };
 227         CGContextSetLineDash(context, patternOffset, dottedLine, 2);
 228     }
 229
 230     CGContextBeginPath(context);
 231     CGContextMoveToPoint(context, p1.x(), p1.y());
 232     CGContextAddLineToPoint(context, p2.x(), p2.y());
 233
 234     CGContextStrokePath(context);
 235
 236     CGContextRestoreGState(context);
 237 }
 238
 239 // This method is only used to draw the little circles used in lists.
 240 void GraphicsContext::drawEllipse(const IntRect& rect)
 241 {
 242     // FIXME: CG added CGContextAddEllipseinRect in Tiger, so we should be able to quite easily draw an ellipse.
 243     // This code can only handle circles, not ellipses. But khtml only
 244     // uses it for circles.
 245     ASSERT(rect.width() == rect.height());
 246
 247     if (paintingDisabled())
 248         return;
 249
 250     CGContextRef context = platformContext();
 251     CGContextBeginPath(context);
 252     float r = (float)rect.width() / 2;
 253     CGContextAddArc(context, rect.x() + r, rect.y() + r, r, 0.0f, 2.0f * piFloat, 0);
 254     CGContextClosePath(context);
 255
 256     if (fillColor().alpha()) {
 257         if (strokeStyle() != NoStroke)
 258             // stroke and fill
 259             CGContextDrawPath(context, kCGPathFillStroke);
 260         else
 261             CGContextFillPath(context);
 262     } else if (strokeStyle() != NoStroke)
 263         CGContextStrokePath(context);
 264 }
 265
 266
 267 void GraphicsContext::strokeArc(const IntRect& rect, int startAngle, int angleSpan)
 268 {
 269     if (paintingDisabled() || strokeStyle() == NoStroke || strokeThickness() <= 0.0f || !strokeColor().alpha())
 270         return;
 271
 272     CGContextRef context = platformContext();
 273     CGContextSaveGState(context);
 274     CGContextBeginPath(context);
 275     CGContextSetShouldAntialias(context, false);
 276
 277     int x = rect.x();
 278     int y = rect.y();
 279     float w = (float)rect.width();
 280     float h = (float)rect.height();
 281     float scaleFactor = h / w;
 282     float reverseScaleFactor = w / h;
 283
 284     if (w != h)
 285         scale(FloatSize(1, scaleFactor));
 286
 287     float hRadius = w / 2;
 288     float vRadius = h / 2;
 289     float fa = startAngle;
 290     float falen =  fa + angleSpan;
 291     float start = -fa * piFloat / 180.0f;
 292     float end = -falen * piFloat / 180.0f;
 293     CGContextAddArc(context, x + hRadius, (y + vRadius) * reverseScaleFactor, hRadius, start, end, true);
 294
 295     if (w != h)
 296         scale(FloatSize(1, reverseScaleFactor));
 297
 298
 299     float width = strokeThickness();
 300     int patWidth = 0;
 301
 302     switch (strokeStyle()) {
 303         case DottedStroke:
 304             patWidth = (int)(width / 2);
 305             break;
 306         case DashedStroke:
 307             patWidth = 3 * (int)(width / 2);
 308             break;
 309         default:
 310             break;
 311     }
 312
 313     if (patWidth) {
 314         // Example: 80 pixels with a width of 30 pixels.
 315         // Remainder is 20.  The maximum pixels of line we could paint
 316         // will be 50 pixels.
 317         int distance;
 318         if (hRadius == vRadius)
 319             distance = static_cast<int>((piFloat * hRadius) / 2.0f);
 320         else // We are elliptical and will have to estimate the distance
 321             distance = static_cast<int>((piFloat * sqrtf((hRadius * hRadius + vRadius * vRadius) / 2.0f)) / 2.0f);
 322
 323         int remainder = distance % patWidth;
 324         int coverage = distance - remainder;
 325         int numSegments = coverage / patWidth;
 326
 327         float patternOffset = 0.0f;
 328         // Special case 1px dotted borders for speed.
 329         if (patWidth == 1)
 330             patternOffset = 1.0f;
 331         else {
 332             bool evenNumberOfSegments = numSegments % 2 == 0;
 333             if (remainder)
 334                 evenNumberOfSegments = !evenNumberOfSegments;
 335             if (evenNumberOfSegments) {
 336                 if (remainder) {
 337                     patternOffset += patWidth - remainder;
 338                     patternOffset += remainder / 2.0f;
 339                 } else
 340                     patternOffset = patWidth / 2.0f;
 341             } else {
 342                 if (remainder)
 343                     patternOffset = (patWidth - remainder) / 2.0f;
 344             }
 345         }
 346
 347         const CGFloat dottedLine[2] = { patWidth, patWidth };
 348         CGContextSetLineDash(context, patternOffset, dottedLine, 2);
 349     }
 350
 351     CGContextStrokePath(context);
 352
 353     CGContextRestoreGState(context);
 354 }
 355
 356 void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias)
 357 {
 358     if (paintingDisabled() || !fillColor().alpha() && (strokeThickness() <= 0 || strokeStyle() == NoStroke))
 359         return;
 360
 361     if (npoints <= 1)
 362         return;
 363
 364     CGContextRef context = platformContext();
 365
 366     CGContextSaveGState(context);
 367
 368     CGContextSetShouldAntialias(context, shouldAntialias);
 369
 370     CGContextBeginPath(context);
 371     CGContextMoveToPoint(context, points[0].x(), points[0].y());
 372     for (size_t i = 1; i < npoints; i++)
 373         CGContextAddLineToPoint(context, points[i].x(), points[i].y());
 374     CGContextClosePath(context);
 375
 376     if (fillColor().alpha()) {
 377         if (strokeStyle() != NoStroke)
 378             CGContextDrawPath(context, kCGPathEOFillStroke);
 379         else
 380             CGContextEOFillPath(context);
 381     } else
 382         CGContextStrokePath(context);
 383
 384     CGContextRestoreGState(context);
 385 }
 386
 387 void GraphicsContext::fillRect(const IntRect& rect, const Color& color)
 388 {
 389     if (paintingDisabled())
 390         return;
 391     if (color.alpha()) {
 392         CGContextRef context = platformContext();
 393         Color oldFillColor = fillColor();
 394         if (oldFillColor != color)
 395             setCGFillColor(context, color);
 396         CGContextFillRect(context, rect);
 397         if (oldFillColor != color)
 398             setCGFillColor(context, oldFillColor);
 399     }
 400 }
 401
 402 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
 403 {
 404     if (paintingDisabled())
 405         return;
 406     if (color.alpha()) {
 407         CGContextRef context = platformContext();
 408         Color oldFillColor = fillColor();
 409         if (oldFillColor != color)
 410             setCGFillColor(context, color);
 411         CGContextFillRect(context, rect);
 412         if (oldFillColor != color)
 413             setCGFillColor(context, oldFillColor);
 414     }
 415 }
 416
 417 void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color)
 418 {
 419     if (paintingDisabled() || !color.alpha())
 420         return;
 421
 422     CGContextRef context = platformContext();
 423     Color oldFillColor = fillColor();
 424     if (oldFillColor != color)
 425         setCGFillColor(context, color);
 426
 427     addPath(Path::createRoundedRectangle(rect, topLeft, topRight, bottomLeft, bottomRight));
 428     CGContextFillPath(context);
 429
 430     if (oldFillColor != color)
 431         setCGFillColor(context, oldFillColor);
 432 }
 433
 434
 435 void GraphicsContext::clip(const IntRect& rect)
 436 {
 437     if (paintingDisabled())
 438         return;
 439     CGContextClipToRect(platformContext(), rect);
 440     m_data->clip(rect);
 441 }
 442
 443 void GraphicsContext::clipOut(const IntRect& rect)
 444 {
 445     if (paintingDisabled())
 446         return;
 447
 448     CGRect rects[2] = { CGContextGetClipBoundingBox(platformContext()), rect };
 449     CGContextBeginPath(platformContext());
 450     CGContextAddRects(platformContext(), rects, 2);
 451     CGContextEOClip(platformContext());
 452 }
 453
 454 void GraphicsContext::clipOutEllipseInRect(const IntRect& rect)
 455 {
 456     if (paintingDisabled())
 457         return;
 458
 459     CGContextBeginPath(platformContext());
 460     CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
 461     CGContextAddEllipseInRect(platformContext(), rect);
 462     CGContextEOClip(platformContext());
 463 }
 464
 465 void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness)
 466 {
 467     if (paintingDisabled())
 468         return;
 469
 470     clip(rect);
 471     CGContextRef context = platformContext();
 472
 473     // Add outer ellipse
 474     CGContextAddEllipseInRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
 475     // Add inner ellipse.
 476     CGContextAddEllipseInRect(context, CGRectMake(rect.x() + thickness, rect.y() + thickness,
 477         rect.width() - (thickness * 2), rect.height() - (thickness * 2)));
 478
 479     CGContextEOClip(context);
 480 }
 481
 482 void GraphicsContext::beginTransparencyLayer(float opacity)
 483 {
 484     if (paintingDisabled())
 485         return;
 486     CGContextRef context = platformContext();
 487     CGContextSaveGState(context);
 488     CGContextSetAlpha(context, opacity);
 489     CGContextBeginTransparencyLayer(context, 0);
 490     m_data->beginTransparencyLayer();
 491     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
 492 }
 493
 494 void GraphicsContext::endTransparencyLayer()
 495 {
 496     if (paintingDisabled())
 497         return;
 498     CGContextRef context = platformContext();
 499     CGContextEndTransparencyLayer(context);
 500     CGContextRestoreGState(context);
 501     m_data->endTransparencyLayer();
 502     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
 503 }
 504
 505 void GraphicsContext::setShadow(const IntSize& size, int blur, const Color& color)
 506 {
 507     // Extreme "blur" values can make text drawing crash or take crazy long times, so clamp
 508     blur = min(blur, 1000);
 509
 510     if (paintingDisabled())
 511         return;
 512     // Check for an invalid color, as this means that the color was not set for the shadow
 513     // and we should therefore just use the default shadow color.
 514     CGContextRef context = platformContext();
 515     if (!color.isValid())
 516         CGContextSetShadow(context, CGSizeMake(size.width(), -size.height()), blur); // y is flipped.
 517     else {
 518         CGColorRef colorCG = cgColor(color);
 519         CGContextSetShadowWithColor(context,
 520                                     CGSizeMake(size.width(), -size.height()), // y is flipped.
 521                                     blur,
 522                                     colorCG);
 523         CGColorRelease(colorCG);
 524     }
 525 }
 526
 527 void GraphicsContext::clearShadow()
 528 {
 529     if (paintingDisabled())
 530         return;
 531     CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
 532 }
 533
 534 void GraphicsContext::setMiterLimit(float limit)
 535 {
 536     if (paintingDisabled())
 537         return;
 538     CGContextSetMiterLimit(platformContext(), limit);
 539 }
 540
 541 void GraphicsContext::setAlpha(float alpha)
 542 {
 543     if (paintingDisabled())
 544         return;
 545     CGContextSetAlpha(platformContext(), alpha);
 546 }
 547
 548 void GraphicsContext::clearRect(const FloatRect& r)
 549 {
 550     if (paintingDisabled())
 551         return;
 552     CGContextClearRect(platformContext(), r);
 553 }
 554
 555 void GraphicsContext::strokeRect(const FloatRect& r, float lineWidth)
 556 {
 557     if (paintingDisabled())
 558         return;
 559     CGContextStrokeRectWithWidth(platformContext(), r, lineWidth);
 560 }
 561
 562 void GraphicsContext::setLineCap(LineCap cap)
 563 {
 564     if (paintingDisabled())
 565         return;
 566     switch (cap) {
 567         case ButtCap:
 568             CGContextSetLineCap(platformContext(), kCGLineCapButt);
 569             break;
 570         case RoundCap:
 571             CGContextSetLineCap(platformContext(), kCGLineCapRound);
 572             break;
 573         case SquareCap:
 574             CGContextSetLineCap(platformContext(), kCGLineCapSquare);
 575             break;
 576     }
 577 }
 578
 579 void GraphicsContext::setLineJoin(LineJoin join)
 580 {
 581     if (paintingDisabled())
 582         return;
 583     switch (join) {
 584         case MiterJoin:
 585             CGContextSetLineJoin(platformContext(), kCGLineJoinMiter);
 586             break;
 587         case RoundJoin:
 588             CGContextSetLineJoin(platformContext(), kCGLineJoinRound);
 589             break;
 590         case BevelJoin:
 591             CGContextSetLineJoin(platformContext(), kCGLineJoinBevel);
 592             break;
 593     }
 594 }
 595
 596 void GraphicsContext::beginPath()
 597 {
 598     CGContextBeginPath(platformContext());
 599 }
 600
 601 void GraphicsContext::addPath(const Path& path)
 602 {
 603     CGContextAddPath(platformContext(), path.platformPath());
 604 }
 605
 606 void GraphicsContext::clip(const Path& path)
 607 {
 608     if (paintingDisabled())
 609         return;
 610     CGContextRef context = platformContext();
 611     CGContextBeginPath(context);
 612     CGContextAddPath(context, path.platformPath());
 613     CGContextClip(context);
 614     m_data->clip(path);
 615 }
 616
 617 void GraphicsContext::clipOut(const Path& path)
 618 {
 619     if (paintingDisabled())
 620         return;
 621
 622     CGContextBeginPath(platformContext());
 623     CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
 624     CGContextAddPath(platformContext(), path.platformPath());
 625     CGContextEOClip(platformContext());
 626 }
 627
 628 void GraphicsContext::scale(const FloatSize& size)
 629 {
 630     if (paintingDisabled())
 631         return;
 632     CGContextScaleCTM(platformContext(), size.width(), size.height());
 633     m_data->scale(size);
 634     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
 635 }
 636
 637 void GraphicsContext::rotate(float angle)
 638 {
 639     if (paintingDisabled())
 640         return;
 641     CGContextRotateCTM(platformContext(), angle);
 642     m_data->rotate(angle);
 643     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
 644 }
 645
 646 void GraphicsContext::translate(float x, float y)
 647 {
 648     if (paintingDisabled())
 649         return;
 650     CGContextTranslateCTM(platformContext(), x, y);
 651     m_data->translate(x, y);
 652     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
 653 }
 654
 655 void GraphicsContext::concatCTM(const AffineTransform& transform)
 656 {
 657     if (paintingDisabled())
 658         return;
 659     CGContextConcatCTM(platformContext(), transform);
 660     m_data->concatCTM(transform);
 661     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
 662 }
 663
 664 FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& rect)
 665 {
 666     // It is not enough just to round to pixels in device space. The rotation part of the
 667     // affine transform matrix to device space can mess with this conversion if we have a
 668     // rotating image like the hands of the world clock widget. We just need the scale, so
 669     // we get the affine transform matrix and extract the scale.
 670
 671     if (m_data->m_userToDeviceTransformKnownToBeIdentity)
 672         return rect;
 673
 674     CGAffineTransform deviceMatrix = CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
 675     if (CGAffineTransformIsIdentity(deviceMatrix)) {
 676         m_data->m_userToDeviceTransformKnownToBeIdentity = true;
 677         return rect;
 678     }
 679
 680     float deviceScaleX = sqrtf(deviceMatrix.a * deviceMatrix.a + deviceMatrix.b * deviceMatrix.b);
 681     float deviceScaleY = sqrtf(deviceMatrix.c * deviceMatrix.c + deviceMatrix.d * deviceMatrix.d);
 682
 683     CGPoint deviceOrigin = CGPointMake(rect.x() * deviceScaleX, rect.y() * deviceScaleY);
 684     CGPoint deviceLowerRight = CGPointMake((rect.x() + rect.width()) * deviceScaleX,
 685         (rect.y() + rect.height()) * deviceScaleY);
 686
 687     deviceOrigin.x = roundf(deviceOrigin.x);
 688     deviceOrigin.y = roundf(deviceOrigin.y);
 689     deviceLowerRight.x = roundf(deviceLowerRight.x);
 690     deviceLowerRight.y = roundf(deviceLowerRight.y);
 691
 692     // Don't let the height or width round to 0 unless either was originally 0
 693     if (deviceOrigin.y == deviceLowerRight.y && rect.height() != 0)
 694         deviceLowerRight.y += 1;
 695     if (deviceOrigin.x == deviceLowerRight.x && rect.width() != 0)
 696         deviceLowerRight.x += 1;
 697
 698     FloatPoint roundedOrigin = FloatPoint(deviceOrigin.x / deviceScaleX, deviceOrigin.y / deviceScaleY);
 699     FloatPoint roundedLowerRight = FloatPoint(deviceLowerRight.x / deviceScaleX, deviceLowerRight.y / deviceScaleY);
 700     return FloatRect(roundedOrigin, roundedLowerRight - roundedOrigin);
 701 }
 702
 703 void GraphicsContext::drawLineForText(const IntPoint& point, int width, bool printing)
 704 {
 705     if (paintingDisabled())
 706         return;
 707
 708     if (width <= 0)
 709         return;
 710
 711     CGContextSaveGState(platformContext());
 712
 713     float x = point.x();
 714     float y = point.y();
 715     float lineLength = width;
 716
 717     // Use a minimum thickness of 0.5 in user space.
 718     // See http://bugs.webkit.org/show_bug.cgi?id=4255 for details of why 0.5 is the right minimum thickness to use.
 719     float thickness = max(strokeThickness(), 0.5f);
 720
 721     if (!printing) {
 722         // On screen, use a minimum thickness of 1.0 in user space (later rounded to an integral number in device space).
 723         float adjustedThickness = max(thickness, 1.0f);
 724
 725         // FIXME: This should be done a better way.
 726         // We try to round all parameters to integer boundaries in device space. If rounding pixels in device space
 727         // makes our thickness more than double, then there must be a shrinking-scale factor and rounding to pixels
 728         // in device space will make the underlines too thick.
 729         CGRect lineRect = roundToDevicePixels(FloatRect(x, y, lineLength, adjustedThickness));
 730         if (lineRect.size.height < thickness * 2.0) {
 731             x = lineRect.origin.x;
 732             y = lineRect.origin.y;
 733             lineLength = lineRect.size.width;
 734             thickness = lineRect.size.height;
 735             CGContextSetShouldAntialias(platformContext(), false);
 736         }
 737     }
 738
 739     if (fillColor() != strokeColor())
 740         setCGFillColor(platformContext(), strokeColor());
 741     CGContextFillRect(platformContext(), CGRectMake(x, y, lineLength, thickness));
 742
 743     CGContextRestoreGState(platformContext());
 744 }
 745
 746 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
 747 {
 748     if (paintingDisabled())
 749         return;
 750
 751     CFURLRef urlRef = link.createCFURL();
 752     if (urlRef) {
 753         CGContextRef context = platformContext();
 754
 755         // Get the bounding box to handle clipping.
 756         CGRect box = CGContextGetClipBoundingBox(context);
 757
 758         IntRect intBox((int)box.origin.x, (int)box.origin.y, (int)box.size.width, (int)box.size.height);
 759         IntRect rect = destRect;
 760         rect.intersect(intBox);
 761
 762         CGPDFContextSetURLForRect(context, urlRef,
 763             CGRectApplyAffineTransform(rect, CGContextGetCTM(context)));
 764
 765         CFRelease(urlRef);
 766     }
 767 }
 768
 769 void GraphicsContext::setUseLowQualityImageInterpolation(bool lowQualityMode)
 770 {
 771     if (paintingDisabled())
 772         return;
 773
 774     CGContextSetInterpolationQuality(platformContext(), lowQualityMode ? kCGInterpolationNone : kCGInterpolationDefault);
 775 }
 776
 777 bool GraphicsContext::useLowQualityImageInterpolation() const
 778 {
 779     if (paintingDisabled())
 780         return false;
 781
 782     return CGContextGetInterpolationQuality(platformContext());
 783 }
 784
 785 void GraphicsContext::setPlatformTextDrawingMode(int mode)
 786 {
 787     if (paintingDisabled())
 788         return;
 789
 790     // Wow, wish CG had used bits here.
 791     CGContextRef context = platformContext();
 792     switch (mode) {
 793         case cTextInvisible: // Invisible
 794             CGContextSetTextDrawingMode(context, kCGTextInvisible);
 795             break;
 796         case cTextFill: // Fill
 797             CGContextSetTextDrawingMode(context, kCGTextFill);
 798             break;
 799         case cTextStroke: // Stroke
 800             CGContextSetTextDrawingMode(context, kCGTextStroke);
 801             break;
 802         case 3: // Fill | Stroke
 803             CGContextSetTextDrawingMode(context, kCGTextFillStroke);
 804             break;
 805         case cTextClip: // Clip
 806             CGContextSetTextDrawingMode(context, kCGTextClip);
 807             break;
 808         case 5: // Fill | Clip
 809             CGContextSetTextDrawingMode(context, kCGTextFillClip);
 810             break;
 811         case 6: // Stroke | Clip
 812             CGContextSetTextDrawingMode(context, kCGTextStrokeClip);
 813             break;
 814         case 7: // Fill | Stroke | Clip
 815             CGContextSetTextDrawingMode(context, kCGTextFillStrokeClip);
 816             break;
 817         default:
 818             break;
 819     }
 820 }
 821
 822 void GraphicsContext::setPlatformStrokeColor(const Color& color)
 823 {
 824     if (paintingDisabled())
 825         return;
 826     setCGStrokeColor(platformContext(), color);
 827 }
 828
 829 void GraphicsContext::setPlatformStrokeThickness(float thickness)
 830 {
 831     if (paintingDisabled())
 832         return;
 833     CGContextSetLineWidth(platformContext(), thickness);
 834 }
 835
 836 void GraphicsContext::setPlatformFillColor(const Color& color)
 837 {
 838     if (paintingDisabled())
 839         return;
 840     setCGFillColor(platformContext(), color);
 841 }
 842
 843 }
 844
 845 #endif // PLATFORM(CG)