WebCore:
[WebKit-https.git] / 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)