<rdar://problem/6164952> Use constant kCGInterpolationMedium in GraphicsContextCG...
[WebKit-https.git] / WebCore / platform / graphics / cg / GraphicsContextCG.cpp
1 /*
2  * Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #define _USE_MATH_DEFINES 1
28 #include "config.h"
29 #include "GraphicsContext.h"
30
31 #include "AffineTransform.h"
32 #include "FloatConversion.h"
33 #include "GraphicsContextPrivate.h"
34 #include "GraphicsContextPlatformPrivateCG.h"
35 #include "ImageBuffer.h"
36 #include "KURL.h"
37 #include "Path.h"
38 #include "Pattern.h"
39 #include <CoreGraphics/CGBitmapContext.h>
40 #include <CoreGraphics/CGPDFContext.h>
41 #include <wtf/MathExtras.h>
42 #include <wtf/OwnArrayPtr.h>
43 #include <wtf/RetainPtr.h>
44
45 #if PLATFORM(MAC) && !defined(BUILDING_ON_TIGER) && !defined(BUILDING_ON_LEOPARD)
46 #define HAVE_CG_INTERPOLATION_MEDIUM 1
47 #endif
48
49 using namespace std;
50
51 namespace WebCore {
52
53 static void setCGFillColor(CGContextRef context, const Color& color)
54 {
55     CGFloat red, green, blue, alpha;
56     color.getRGBA(red, green, blue, alpha);
57     CGContextSetRGBFillColor(context, red, green, blue, alpha);
58 }
59
60 static void setCGStrokeColor(CGContextRef context, const Color& color)
61 {
62     CGFloat red, green, blue, alpha;
63     color.getRGBA(red, green, blue, alpha);
64     CGContextSetRGBStrokeColor(context, red, green, blue, alpha);
65 }
66
67 GraphicsContext::GraphicsContext(CGContextRef cgContext)
68     : m_common(createGraphicsContextPrivate())
69     , m_data(new GraphicsContextPlatformPrivate(cgContext))
70 {
71     setPaintingDisabled(!cgContext);
72     if (cgContext) {
73         // Make sure the context starts in sync with our state.
74         setPlatformFillColor(fillColor());
75         setPlatformStrokeColor(strokeColor());
76     }
77 }
78
79 GraphicsContext::~GraphicsContext()
80 {
81     destroyGraphicsContextPrivate(m_common);
82     delete m_data;
83 }
84
85 CGContextRef GraphicsContext::platformContext() const
86 {
87     ASSERT(!paintingDisabled());
88     ASSERT(m_data->m_cgContext);
89     return m_data->m_cgContext;
90 }
91
92 void GraphicsContext::savePlatformState()
93 {
94     // Note: Do not use this function within this class implementation, since we want to avoid the extra
95     // save of the secondary context (in GraphicsContextPlatformPrivateCG.h).
96     CGContextSaveGState(platformContext());
97     m_data->save();
98 }
99
100 void GraphicsContext::restorePlatformState()
101 {
102     // Note: Do not use this function within this class implementation, since we want to avoid the extra
103     // restore of the secondary context (in GraphicsContextPlatformPrivateCG.h).
104     CGContextRestoreGState(platformContext());
105     m_data->restore();
106     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
107 }
108
109 // Draws a filled rectangle with a stroked border.
110 void GraphicsContext::drawRect(const IntRect& rect)
111 {
112     // FIXME: this function does not handle patterns and gradients
113     // like drawPath does, it probably should.
114     if (paintingDisabled())
115         return;
116
117     CGContextRef context = platformContext();
118
119     if (fillColor().alpha())
120         CGContextFillRect(context, rect);
121
122     if (strokeStyle() != NoStroke && strokeColor().alpha()) {
123         // We do a fill of four rects to simulate the stroke of a border.
124         Color oldFillColor = fillColor();
125         if (oldFillColor != strokeColor())
126             setCGFillColor(context, strokeColor());
127         CGRect rects[4] = {
128             FloatRect(rect.x(), rect.y(), rect.width(), 1),
129             FloatRect(rect.x(), rect.bottom() - 1, rect.width(), 1),
130             FloatRect(rect.x(), rect.y() + 1, 1, rect.height() - 2),
131             FloatRect(rect.right() - 1, rect.y() + 1, 1, rect.height() - 2)
132         };
133         CGContextFillRects(context, rects, 4);
134         if (oldFillColor != strokeColor())
135             setCGFillColor(context, oldFillColor);
136     }
137 }
138
139 // This is only used to draw borders.
140 void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
141 {
142     if (paintingDisabled())
143         return;
144
145     if (strokeStyle() == NoStroke || !strokeColor().alpha())
146         return;
147
148     float width = strokeThickness();
149
150     FloatPoint p1 = point1;
151     FloatPoint p2 = point2;
152     bool isVerticalLine = (p1.x() == p2.x());
153     
154     // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic
155     // works out.  For example, with a border width of 3, KHTML will pass us (y1+y2)/2, e.g.,
156     // (50+53)/2 = 103/2 = 51 when we want 51.5.  It is always true that an even width gave
157     // us a perfect position, but an odd width gave us a position that is off by exactly 0.5.
158     if (strokeStyle() == DottedStroke || strokeStyle() == DashedStroke) {
159         if (isVerticalLine) {
160             p1.move(0, width);
161             p2.move(0, -width);
162         } else {
163             p1.move(width, 0);
164             p2.move(-width, 0);
165         }
166     }
167     
168     if (((int)width) % 2) {
169         if (isVerticalLine) {
170             // We're a vertical line.  Adjust our x.
171             p1.move(0.5f, 0.0f);
172             p2.move(0.5f, 0.0f);
173         } else {
174             // We're a horizontal line. Adjust our y.
175             p1.move(0.0f, 0.5f);
176             p2.move(0.0f, 0.5f);
177         }
178     }
179     
180     int patWidth = 0;
181     switch (strokeStyle()) {
182         case NoStroke:
183         case SolidStroke:
184             break;
185         case DottedStroke:
186             patWidth = (int)width;
187             break;
188         case DashedStroke:
189             patWidth = 3 * (int)width;
190             break;
191     }
192
193     CGContextRef context = platformContext();
194     CGContextSaveGState(context);
195
196     CGContextSetShouldAntialias(context, false);
197
198     if (patWidth) {
199         // Do a rect fill of our endpoints.  This ensures we always have the
200         // appearance of being a border.  We then draw the actual dotted/dashed line.
201         setCGFillColor(context, strokeColor());  // The save/restore make it safe to mutate the fill color here without setting it back to the old color.
202         if (isVerticalLine) {
203             CGContextFillRect(context, FloatRect(p1.x() - width / 2, p1.y() - width, width, width));
204             CGContextFillRect(context, FloatRect(p2.x() - width / 2, p2.y(), width, width));
205         } else {
206             CGContextFillRect(context, FloatRect(p1.x() - width, p1.y() - width / 2, width, width));
207             CGContextFillRect(context, FloatRect(p2.x(), p2.y() - width / 2, width, width));
208         }
209
210         // Example: 80 pixels with a width of 30 pixels.
211         // Remainder is 20.  The maximum pixels of line we could paint
212         // will be 50 pixels.
213         int distance = (isVerticalLine ? (point2.y() - point1.y()) : (point2.x() - point1.x())) - 2*(int)width;
214         int remainder = distance % patWidth;
215         int coverage = distance - remainder;
216         int numSegments = coverage / patWidth;
217
218         float patternOffset = 0.0f;
219         // Special case 1px dotted borders for speed.
220         if (patWidth == 1)
221             patternOffset = 1.0f;
222         else {
223             bool evenNumberOfSegments = numSegments % 2 == 0;
224             if (remainder)
225                 evenNumberOfSegments = !evenNumberOfSegments;
226             if (evenNumberOfSegments) {
227                 if (remainder) {
228                     patternOffset += patWidth - remainder;
229                     patternOffset += remainder / 2;
230                 } else
231                     patternOffset = patWidth / 2;
232             } else {
233                 if (remainder)
234                     patternOffset = (patWidth - remainder)/2;
235             }
236         }
237         
238         const CGFloat dottedLine[2] = { patWidth, patWidth };
239         CGContextSetLineDash(context, patternOffset, dottedLine, 2);
240     }
241
242     CGContextBeginPath(context);
243     CGContextMoveToPoint(context, p1.x(), p1.y());
244     CGContextAddLineToPoint(context, p2.x(), p2.y());
245
246     CGContextStrokePath(context);
247
248     CGContextRestoreGState(context);
249 }
250
251 // This method is only used to draw the little circles used in lists.
252 void GraphicsContext::drawEllipse(const IntRect& rect)
253 {
254     // FIXME: CG added CGContextAddEllipseinRect in Tiger, so we should be able to quite easily draw an ellipse.
255     // This code can only handle circles, not ellipses. But khtml only
256     // uses it for circles.
257     ASSERT(rect.width() == rect.height());
258
259     if (paintingDisabled())
260         return;
261         
262     CGContextRef context = platformContext();
263     CGContextBeginPath(context);
264     float r = (float)rect.width() / 2;
265     CGContextAddArc(context, rect.x() + r, rect.y() + r, r, 0.0f, 2.0f * piFloat, 0);
266     CGContextClosePath(context);
267
268     drawPath();
269 }
270
271
272 void GraphicsContext::strokeArc(const IntRect& rect, int startAngle, int angleSpan)
273
274     if (paintingDisabled() || strokeStyle() == NoStroke || strokeThickness() <= 0.0f || !strokeColor().alpha())
275         return;
276     
277     CGContextRef context = platformContext();
278     CGContextSaveGState(context);
279     CGContextBeginPath(context);
280     CGContextSetShouldAntialias(context, false);
281     
282     int x = rect.x();
283     int y = rect.y();
284     float w = (float)rect.width();
285     float h = (float)rect.height();
286     float scaleFactor = h / w;
287     float reverseScaleFactor = w / h;
288     
289     if (w != h)
290         scale(FloatSize(1, scaleFactor));
291     
292     float hRadius = w / 2;
293     float vRadius = h / 2;
294     float fa = startAngle;
295     float falen =  fa + angleSpan;
296     float start = -fa * piFloat / 180.0f;
297     float end = -falen * piFloat / 180.0f;
298     CGContextAddArc(context, x + hRadius, (y + vRadius) * reverseScaleFactor, hRadius, start, end, true);
299
300     if (w != h)
301         scale(FloatSize(1, reverseScaleFactor));
302     
303     
304     float width = strokeThickness();
305     int patWidth = 0;
306     
307     switch (strokeStyle()) {
308         case DottedStroke:
309             patWidth = (int)(width / 2);
310             break;
311         case DashedStroke:
312             patWidth = 3 * (int)(width / 2);
313             break;
314         default:
315             break;
316     }
317     
318     if (patWidth) {
319         // Example: 80 pixels with a width of 30 pixels.
320         // Remainder is 20.  The maximum pixels of line we could paint
321         // will be 50 pixels.
322         int distance;
323         if (hRadius == vRadius)
324             distance = static_cast<int>((piFloat * hRadius) / 2.0f);
325         else // We are elliptical and will have to estimate the distance
326             distance = static_cast<int>((piFloat * sqrtf((hRadius * hRadius + vRadius * vRadius) / 2.0f)) / 2.0f);
327         
328         int remainder = distance % patWidth;
329         int coverage = distance - remainder;
330         int numSegments = coverage / patWidth;
331
332         float patternOffset = 0.0f;
333         // Special case 1px dotted borders for speed.
334         if (patWidth == 1)
335             patternOffset = 1.0f;
336         else {
337             bool evenNumberOfSegments = numSegments % 2 == 0;
338             if (remainder)
339                 evenNumberOfSegments = !evenNumberOfSegments;
340             if (evenNumberOfSegments) {
341                 if (remainder) {
342                     patternOffset += patWidth - remainder;
343                     patternOffset += remainder / 2.0f;
344                 } else
345                     patternOffset = patWidth / 2.0f;
346             } else {
347                 if (remainder)
348                     patternOffset = (patWidth - remainder) / 2.0f;
349             }
350         }
351     
352         const CGFloat dottedLine[2] = { patWidth, patWidth };
353         CGContextSetLineDash(context, patternOffset, dottedLine, 2);
354     }
355
356     CGContextStrokePath(context);
357     
358     CGContextRestoreGState(context);
359 }
360
361 void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias)
362 {
363     if (paintingDisabled() || !fillColor().alpha() && (strokeThickness() <= 0 || strokeStyle() == NoStroke))
364         return;
365
366     if (npoints <= 1)
367         return;
368
369     CGContextRef context = platformContext();
370
371     CGContextSaveGState(context);
372
373     CGContextSetShouldAntialias(context, shouldAntialias);
374     
375     CGContextBeginPath(context);
376     CGContextMoveToPoint(context, points[0].x(), points[0].y());
377     for (size_t i = 1; i < npoints; i++)
378         CGContextAddLineToPoint(context, points[i].x(), points[i].y());
379     CGContextClosePath(context);
380
381     drawPath();
382
383     CGContextRestoreGState(context);
384 }
385
386 static void applyStrokePattern(GraphicsContext* context, Pattern* pattern)
387 {
388     CGContextRef cgContext = context->platformContext();
389     
390     CGPatternRef platformPattern = pattern->createPlatformPattern(context->getCTM());
391     if (!platformPattern)
392         return;
393
394     CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(0);
395     CGContextSetStrokeColorSpace(cgContext, patternSpace);
396     CGColorSpaceRelease(patternSpace);
397
398     const CGFloat patternAlpha = 1;
399     CGContextSetStrokePattern(cgContext, platformPattern, &patternAlpha);
400     CGPatternRelease(platformPattern);
401 }
402
403 static void applyFillPattern(GraphicsContext* context, Pattern* pattern)
404 {
405     CGContextRef cgContext = context->platformContext();
406
407     CGPatternRef platformPattern = pattern->createPlatformPattern(context->getCTM());
408     if (!platformPattern)
409         return;
410
411     CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(0);
412     CGContextSetFillColorSpace(cgContext, patternSpace);
413     CGColorSpaceRelease(patternSpace);
414
415     const CGFloat patternAlpha = 1;
416     CGContextSetFillPattern(cgContext, platformPattern, &patternAlpha);
417     CGPatternRelease(platformPattern);
418 }
419
420 static inline bool calculateDrawingMode(const GraphicsContextState& state, CGPathDrawingMode& mode)
421 {
422     bool shouldFill = state.fillColorSpace == PatternColorSpace || state.fillColor.alpha();
423     bool shouldStroke = state.strokeColorSpace == PatternColorSpace || (state.strokeStyle != NoStroke && state.strokeColor.alpha());
424     bool useEOFill = state.fillRule == RULE_EVENODD;
425
426     if (shouldFill) {
427         if (shouldStroke) {
428             if (useEOFill)
429                 mode = kCGPathEOFillStroke;
430             else
431                 mode = kCGPathFillStroke;
432         } else { // fill, no stroke
433             if (useEOFill)
434                 mode = kCGPathEOFill;
435             else
436                 mode = kCGPathFill;
437         }
438     } else {
439         // Setting mode to kCGPathStroke even if shouldStroke is false. In that case, we return false and mode will not be used,
440         // but the compiler will not compain about an uninitialized variable.
441         mode = kCGPathStroke;
442     }
443
444     return shouldFill || shouldStroke;
445 }
446
447 void GraphicsContext::drawPath()
448 {
449     if (paintingDisabled())
450         return;
451
452     CGContextRef context = platformContext();
453     const GraphicsContextState& state = m_common->state;
454
455     if (state.fillColorSpace == GradientColorSpace || state.strokeColorSpace == GradientColorSpace) {
456         // We don't have any optimized way to fill & stroke a path using gradients
457         fillPath();
458         strokePath();
459         return;
460     }
461     
462     if (state.fillColorSpace == PatternColorSpace)
463         applyFillPattern(this, m_common->state.fillPattern.get());
464     if (state.strokeColorSpace == PatternColorSpace)
465         applyStrokePattern(this, m_common->state.strokePattern.get());
466
467     CGPathDrawingMode drawingMode;
468     if (calculateDrawingMode(state, drawingMode))
469         CGContextDrawPath(context, drawingMode);
470 }
471
472 static inline void fillPathWithFillRule(CGContextRef context, WindRule fillRule)
473 {
474     if (fillRule == RULE_EVENODD)
475         CGContextEOFillPath(context);
476     else
477         CGContextFillPath(context);
478 }
479
480 void GraphicsContext::fillPath()
481 {
482     if (paintingDisabled())
483         return;
484
485     CGContextRef context = platformContext();
486     switch (m_common->state.fillColorSpace) {
487     case SolidColorSpace:
488         if (fillColor().alpha())
489             fillPathWithFillRule(context, fillRule());
490         break;
491     case PatternColorSpace:
492         applyFillPattern(this, m_common->state.fillPattern.get());
493         fillPathWithFillRule(context, fillRule());
494         break;
495     case GradientColorSpace:
496         CGContextSaveGState(context);
497         if (fillRule() == RULE_EVENODD)
498             CGContextEOClip(context);
499         else
500             CGContextClip(context);
501         CGContextDrawShading(context, m_common->state.fillGradient->platformGradient());
502         CGContextRestoreGState(context);
503         break;
504     }
505 }
506
507 void GraphicsContext::strokePath()
508 {
509     if (paintingDisabled())
510         return;
511
512     CGContextRef context = platformContext();
513     switch (m_common->state.strokeColorSpace) {
514     case SolidColorSpace:
515         if (fillColor().alpha())
516             CGContextStrokePath(context);
517         break;
518     case PatternColorSpace:
519         applyStrokePattern(this, m_common->state.strokePattern.get());
520         CGContextStrokePath(context);
521         break;
522     case GradientColorSpace:
523         CGContextSaveGState(context);
524         CGContextReplacePathWithStrokedPath(context);
525         CGContextClip(context);
526         CGContextDrawShading(context, m_common->state.strokeGradient->platformGradient());
527         CGContextRestoreGState(context);
528         break;
529     }
530 }
531
532 void GraphicsContext::fillRect(const FloatRect& rect)
533 {
534     if (paintingDisabled())
535         return;
536     CGContextRef context = platformContext();
537     switch (m_common->state.fillColorSpace) {
538     case SolidColorSpace:
539         if (fillColor().alpha())
540             CGContextFillRect(context, rect);
541         break;
542     case PatternColorSpace:
543         applyFillPattern(this, m_common->state.fillPattern.get());
544         CGContextFillRect(context, rect);
545         break;
546     case GradientColorSpace:
547         CGContextSaveGState(context);
548         CGContextClipToRect(context, rect);
549         CGContextDrawShading(context, m_common->state.fillGradient->platformGradient());
550         CGContextRestoreGState(context);
551         break;
552     }
553 }
554
555 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
556 {
557     if (paintingDisabled())
558         return;
559     if (color.alpha()) {
560         CGContextRef context = platformContext();
561         Color oldFillColor = fillColor();
562         if (oldFillColor != color)
563             setCGFillColor(context, color);
564         CGContextFillRect(context, rect);
565         if (oldFillColor != color)
566             setCGFillColor(context, oldFillColor);
567     }
568 }
569
570 void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color)
571 {
572     if (paintingDisabled() || !color.alpha())
573         return;
574
575     CGContextRef context = platformContext();
576     Color oldFillColor = fillColor();
577     if (oldFillColor != color)
578         setCGFillColor(context, color);
579
580     addPath(Path::createRoundedRectangle(rect, topLeft, topRight, bottomLeft, bottomRight));
581     fillPath();
582
583     if (oldFillColor != color)
584         setCGFillColor(context, oldFillColor);
585 }
586
587 void GraphicsContext::clip(const FloatRect& rect)
588 {
589     if (paintingDisabled())
590         return;
591     CGContextClipToRect(platformContext(), rect);
592     m_data->clip(rect);
593 }
594
595 void GraphicsContext::clipOut(const IntRect& rect)
596 {
597     if (paintingDisabled())
598         return;
599         
600     CGRect rects[2] = { CGContextGetClipBoundingBox(platformContext()), rect };
601     CGContextBeginPath(platformContext());
602     CGContextAddRects(platformContext(), rects, 2);
603     CGContextEOClip(platformContext());
604 }
605
606 void GraphicsContext::clipOutEllipseInRect(const IntRect& rect)
607 {
608     if (paintingDisabled())
609         return;
610         
611     CGContextBeginPath(platformContext());
612     CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
613     CGContextAddEllipseInRect(platformContext(), rect);
614     CGContextEOClip(platformContext());
615 }
616
617 void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness)
618 {
619     if (paintingDisabled())
620         return;
621
622     clip(rect);
623     CGContextRef context = platformContext();
624     
625     // Add outer ellipse
626     CGContextAddEllipseInRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
627     // Add inner ellipse.
628     CGContextAddEllipseInRect(context, CGRectMake(rect.x() + thickness, rect.y() + thickness,
629         rect.width() - (thickness * 2), rect.height() - (thickness * 2)));
630     
631     CGContextEOClip(context);
632 }
633
634 void GraphicsContext::clipToImageBuffer(const FloatRect& rect, const ImageBuffer* imageBuffer)
635 {
636     if (paintingDisabled())
637         return;
638     
639     CGContextTranslateCTM(platformContext(), rect.x(), rect.y() + rect.height());
640     CGContextScaleCTM(platformContext(), 1, -1);
641     CGContextClipToMask(platformContext(), FloatRect(FloatPoint(), rect.size()), imageBuffer->image()->getCGImageRef());
642     CGContextScaleCTM(platformContext(), 1, -1);
643     CGContextTranslateCTM(platformContext(), -rect.x(), -rect.y() - rect.height());
644 }
645
646 void GraphicsContext::beginTransparencyLayer(float opacity)
647 {
648     if (paintingDisabled())
649         return;
650     CGContextRef context = platformContext();
651     CGContextSaveGState(context);
652     CGContextSetAlpha(context, opacity);
653     CGContextBeginTransparencyLayer(context, 0);
654     m_data->beginTransparencyLayer();
655     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
656 }
657
658 void GraphicsContext::endTransparencyLayer()
659 {
660     if (paintingDisabled())
661         return;
662     CGContextRef context = platformContext();
663     CGContextEndTransparencyLayer(context);
664     CGContextRestoreGState(context);
665     m_data->endTransparencyLayer();
666     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
667 }
668
669 void GraphicsContext::setPlatformShadow(const IntSize& size, int blur, const Color& color)
670 {
671     if (paintingDisabled())
672         return;
673     CGContextRef context = platformContext();
674     CGAffineTransform transform = CGContextGetCTM(context);
675
676     CGFloat A = transform.a * transform.a + transform.b * transform.b;
677     CGFloat B = transform.a * transform.c + transform.b * transform.d;
678     CGFloat C = B;
679     CGFloat D = transform.c * transform.c + transform.d * transform.d;
680
681     CGFloat smallEigenvalue = narrowPrecisionToCGFloat(sqrt(0.5 * ((A + D) - sqrt(4 * B * C + (A - D) * (A - D)))));
682
683     // Extreme "blur" values can make text drawing crash or take crazy long times, so clamp
684     CGFloat blurRadius = min(blur * smallEigenvalue, narrowPrecisionToCGFloat(1000.0));
685
686     CGSize sizeInDeviceSpace = CGSizeApplyAffineTransform(size, transform);
687
688     CGFloat width = sizeInDeviceSpace.width;
689     CGFloat height = sizeInDeviceSpace.height;
690
691     // Work around <rdar://problem/5539388> by ensuring that the offsets will get truncated
692     // to the desired integer.
693     static const CGFloat extraShadowOffset = narrowPrecisionToCGFloat(1.0 / 128);
694     if (width > 0)
695         width += extraShadowOffset;
696     else if (width < 0)
697         width -= extraShadowOffset;
698
699     if (height > 0)
700         height += extraShadowOffset;
701     else if (height < 0)
702         height -= extraShadowOffset;
703
704     // Check for an invalid color, as this means that the color was not set for the shadow
705     // and we should therefore just use the default shadow color.
706     if (!color.isValid())
707         CGContextSetShadow(context, CGSizeMake(width, height), blurRadius);
708     else {
709         CGColorRef colorCG = cgColor(color);
710         CGContextSetShadowWithColor(context,
711                                     CGSizeMake(width, height),
712                                     blurRadius, 
713                                     colorCG);
714         CGColorRelease(colorCG);
715     }
716 }
717
718 void GraphicsContext::clearPlatformShadow()
719 {
720     if (paintingDisabled())
721         return;
722     CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
723 }
724
725 void GraphicsContext::setMiterLimit(float limit)
726 {
727     if (paintingDisabled())
728         return;
729     CGContextSetMiterLimit(platformContext(), limit);
730 }
731
732 void GraphicsContext::setAlpha(float alpha)
733 {
734     if (paintingDisabled())
735         return;
736     CGContextSetAlpha(platformContext(), alpha);
737 }
738
739 void GraphicsContext::clearRect(const FloatRect& r)
740 {
741     if (paintingDisabled())
742         return;
743     CGContextClearRect(platformContext(), r);
744 }
745
746 void GraphicsContext::strokeRect(const FloatRect& r, float lineWidth)
747 {
748     if (paintingDisabled())
749         return;
750     CGContextStrokeRectWithWidth(platformContext(), r, lineWidth);
751 }
752
753 void GraphicsContext::setLineCap(LineCap cap)
754 {
755     if (paintingDisabled())
756         return;
757     switch (cap) {
758         case ButtCap:
759             CGContextSetLineCap(platformContext(), kCGLineCapButt);
760             break;
761         case RoundCap:
762             CGContextSetLineCap(platformContext(), kCGLineCapRound);
763             break;
764         case SquareCap:
765             CGContextSetLineCap(platformContext(), kCGLineCapSquare);
766             break;
767     }
768 }
769
770 void GraphicsContext::setLineDash(const DashArray& dashes, float dashOffset)
771 {
772     CGContextSetLineDash(platformContext(), dashOffset, dashes.data(), dashes.size());
773 }
774
775 void GraphicsContext::setLineJoin(LineJoin join)
776 {
777     if (paintingDisabled())
778         return;
779     switch (join) {
780         case MiterJoin:
781             CGContextSetLineJoin(platformContext(), kCGLineJoinMiter);
782             break;
783         case RoundJoin:
784             CGContextSetLineJoin(platformContext(), kCGLineJoinRound);
785             break;
786         case BevelJoin:
787             CGContextSetLineJoin(platformContext(), kCGLineJoinBevel);
788             break;
789     }
790 }
791
792 void GraphicsContext::beginPath()
793 {
794     CGContextBeginPath(platformContext());
795 }
796
797 void GraphicsContext::addPath(const Path& path)
798 {
799     CGContextAddPath(platformContext(), path.platformPath());
800 }
801
802 void GraphicsContext::clip(const Path& path)
803 {
804     if (paintingDisabled())
805         return;
806     CGContextRef context = platformContext();
807     CGContextBeginPath(context);
808     CGContextAddPath(context, path.platformPath());
809     CGContextClip(context);
810     m_data->clip(path);
811 }
812
813 void GraphicsContext::clipOut(const Path& path)
814 {
815     if (paintingDisabled())
816         return;
817         
818     CGContextBeginPath(platformContext());
819     CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
820     CGContextAddPath(platformContext(), path.platformPath());
821     CGContextEOClip(platformContext());
822 }
823
824 void GraphicsContext::scale(const FloatSize& size)
825 {
826     if (paintingDisabled())
827         return;
828     CGContextScaleCTM(platformContext(), size.width(), size.height());
829     m_data->scale(size);
830     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
831 }
832
833 void GraphicsContext::rotate(float angle)
834 {
835     if (paintingDisabled())
836         return;
837     CGContextRotateCTM(platformContext(), angle);
838     m_data->rotate(angle);
839     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
840 }
841
842 void GraphicsContext::translate(float x, float y)
843 {
844     if (paintingDisabled())
845         return;
846     CGContextTranslateCTM(platformContext(), x, y);
847     m_data->translate(x, y);
848     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
849 }
850
851 void GraphicsContext::concatCTM(const AffineTransform& transform)
852 {
853     if (paintingDisabled())
854         return;
855     CGContextConcatCTM(platformContext(), transform);
856     m_data->concatCTM(transform);
857     m_data->m_userToDeviceTransformKnownToBeIdentity = false;
858 }
859
860 AffineTransform GraphicsContext::getCTM() const
861 {
862     return CGContextGetCTM(platformContext());
863 }
864
865 FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& rect)
866 {
867     // It is not enough just to round to pixels in device space. The rotation part of the 
868     // affine transform matrix to device space can mess with this conversion if we have a
869     // rotating image like the hands of the world clock widget. We just need the scale, so 
870     // we get the affine transform matrix and extract the scale.
871
872     if (m_data->m_userToDeviceTransformKnownToBeIdentity)
873         return rect;
874
875     CGAffineTransform deviceMatrix = CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
876     if (CGAffineTransformIsIdentity(deviceMatrix)) {
877         m_data->m_userToDeviceTransformKnownToBeIdentity = true;
878         return rect;
879     }
880
881     float deviceScaleX = sqrtf(deviceMatrix.a * deviceMatrix.a + deviceMatrix.b * deviceMatrix.b);
882     float deviceScaleY = sqrtf(deviceMatrix.c * deviceMatrix.c + deviceMatrix.d * deviceMatrix.d);
883
884     CGPoint deviceOrigin = CGPointMake(rect.x() * deviceScaleX, rect.y() * deviceScaleY);
885     CGPoint deviceLowerRight = CGPointMake((rect.x() + rect.width()) * deviceScaleX,
886         (rect.y() + rect.height()) * deviceScaleY);
887
888     deviceOrigin.x = roundf(deviceOrigin.x);
889     deviceOrigin.y = roundf(deviceOrigin.y);
890     deviceLowerRight.x = roundf(deviceLowerRight.x);
891     deviceLowerRight.y = roundf(deviceLowerRight.y);
892     
893     // Don't let the height or width round to 0 unless either was originally 0
894     if (deviceOrigin.y == deviceLowerRight.y && rect.height() != 0)
895         deviceLowerRight.y += 1;
896     if (deviceOrigin.x == deviceLowerRight.x && rect.width() != 0)
897         deviceLowerRight.x += 1;
898
899     FloatPoint roundedOrigin = FloatPoint(deviceOrigin.x / deviceScaleX, deviceOrigin.y / deviceScaleY);
900     FloatPoint roundedLowerRight = FloatPoint(deviceLowerRight.x / deviceScaleX, deviceLowerRight.y / deviceScaleY);
901     return FloatRect(roundedOrigin, roundedLowerRight - roundedOrigin);
902 }
903
904 void GraphicsContext::drawLineForText(const IntPoint& point, int width, bool printing)
905 {
906     if (paintingDisabled())
907         return;
908
909     if (width <= 0)
910         return;
911
912     CGContextSaveGState(platformContext());
913
914     float x = point.x();
915     float y = point.y();
916     float lineLength = width;
917
918     // Use a minimum thickness of 0.5 in user space.
919     // See http://bugs.webkit.org/show_bug.cgi?id=4255 for details of why 0.5 is the right minimum thickness to use.
920     float thickness = max(strokeThickness(), 0.5f);
921
922     if (!printing) {
923         // On screen, use a minimum thickness of 1.0 in user space (later rounded to an integral number in device space).
924         float adjustedThickness = max(thickness, 1.0f);
925
926         // FIXME: This should be done a better way.
927         // We try to round all parameters to integer boundaries in device space. If rounding pixels in device space
928         // makes our thickness more than double, then there must be a shrinking-scale factor and rounding to pixels
929         // in device space will make the underlines too thick.
930         CGRect lineRect = roundToDevicePixels(FloatRect(x, y, lineLength, adjustedThickness));
931         if (lineRect.size.height < thickness * 2.0) {
932             x = lineRect.origin.x;
933             y = lineRect.origin.y;
934             lineLength = lineRect.size.width;
935             thickness = lineRect.size.height;
936             CGContextSetShouldAntialias(platformContext(), false);
937         }
938     }
939     
940     if (fillColor() != strokeColor())
941         setCGFillColor(platformContext(), strokeColor());
942     CGContextFillRect(platformContext(), CGRectMake(x, y, lineLength, thickness));
943
944     CGContextRestoreGState(platformContext());
945 }
946
947 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
948 {
949     if (paintingDisabled())
950         return;
951         
952     CFURLRef urlRef = link.createCFURL();
953     if (urlRef) {
954         CGContextRef context = platformContext();
955         
956         // Get the bounding box to handle clipping.
957         CGRect box = CGContextGetClipBoundingBox(context);
958
959         IntRect intBox((int)box.origin.x, (int)box.origin.y, (int)box.size.width, (int)box.size.height);
960         IntRect rect = destRect;
961         rect.intersect(intBox);
962
963         CGPDFContextSetURLForRect(context, urlRef,
964             CGRectApplyAffineTransform(rect, CGContextGetCTM(context)));
965
966         CFRelease(urlRef);
967     }
968 }
969
970 void GraphicsContext::setImageInterpolationQuality(InterpolationQuality mode)
971 {
972     if (paintingDisabled())
973         return;
974     
975     CGInterpolationQuality quality = kCGInterpolationDefault;
976     switch (mode) {
977         case InterpolationDefault:
978             quality = kCGInterpolationDefault;
979             break;
980         case InterpolationNone:
981             quality = kCGInterpolationNone;
982             break;
983         case InterpolationLow:
984             quality = kCGInterpolationLow;
985             break;
986
987         // Fall through to InterpolationHigh if kCGInterpolationMedium is not available
988         case InterpolationMedium:
989 #if HAVE(CG_INTERPOLATION_MEDIUM)
990             quality = kCGInterpolationMedium;
991             break;
992 #endif
993         case InterpolationHigh:
994             quality = kCGInterpolationHigh;
995             break;
996     }
997     CGContextSetInterpolationQuality(platformContext(), quality);
998 }
999
1000 InterpolationQuality GraphicsContext::imageInterpolationQuality() const
1001 {
1002     if (paintingDisabled())
1003         return InterpolationDefault;
1004
1005     CGInterpolationQuality quality = CGContextGetInterpolationQuality(platformContext());
1006     switch (quality) {
1007         case kCGInterpolationDefault:
1008             return InterpolationDefault;
1009         case kCGInterpolationNone:
1010             return InterpolationNone;
1011         case kCGInterpolationLow:
1012             return InterpolationLow;
1013 #if HAVE(CG_INTERPOLATION_MEDIUM)
1014         case kCGInterpolationMedium:
1015             return InterpolationMedium;
1016 #endif
1017         case kCGInterpolationHigh:
1018             return InterpolationHigh;
1019     }
1020     return InterpolationDefault;
1021 }
1022
1023 void GraphicsContext::setPlatformTextDrawingMode(int mode)
1024 {
1025     if (paintingDisabled())
1026         return;
1027
1028     // Wow, wish CG had used bits here.
1029     CGContextRef context = platformContext();
1030     switch (mode) {
1031         case cTextInvisible: // Invisible
1032             CGContextSetTextDrawingMode(context, kCGTextInvisible);
1033             break;
1034         case cTextFill: // Fill
1035             CGContextSetTextDrawingMode(context, kCGTextFill);
1036             break;
1037         case cTextStroke: // Stroke
1038             CGContextSetTextDrawingMode(context, kCGTextStroke);
1039             break;
1040         case 3: // Fill | Stroke
1041             CGContextSetTextDrawingMode(context, kCGTextFillStroke);
1042             break;
1043         case cTextClip: // Clip
1044             CGContextSetTextDrawingMode(context, kCGTextClip);
1045             break;
1046         case 5: // Fill | Clip
1047             CGContextSetTextDrawingMode(context, kCGTextFillClip);
1048             break;
1049         case 6: // Stroke | Clip
1050             CGContextSetTextDrawingMode(context, kCGTextStrokeClip);
1051             break;
1052         case 7: // Fill | Stroke | Clip
1053             CGContextSetTextDrawingMode(context, kCGTextFillStrokeClip);
1054             break;
1055         default:
1056             break;
1057     }
1058 }
1059
1060 void GraphicsContext::setPlatformStrokeColor(const Color& color)
1061 {
1062     if (paintingDisabled())
1063         return;
1064     setCGStrokeColor(platformContext(), color);
1065 }
1066
1067 void GraphicsContext::setPlatformStrokeThickness(float thickness)
1068 {
1069     if (paintingDisabled())
1070         return;
1071     CGContextSetLineWidth(platformContext(), thickness);
1072 }
1073
1074 void GraphicsContext::setPlatformFillColor(const Color& color)
1075 {
1076     if (paintingDisabled())
1077         return;
1078     setCGFillColor(platformContext(), color);
1079 }
1080
1081 void GraphicsContext::setUseAntialiasing(bool enable)
1082 {
1083     if (paintingDisabled())
1084         return;
1085     CGContextSetShouldAntialias(platformContext(), enable);
1086 }
1087
1088 #ifndef BUILDING_ON_TIGER // Tiger's setCompositeOperation() is defined in GraphicsContextMac.mm.
1089 void GraphicsContext::setCompositeOperation(CompositeOperator mode)
1090 {   
1091     if (paintingDisabled())
1092         return;
1093
1094     CGBlendMode target = kCGBlendModeNormal;   
1095     switch (mode) {
1096         case CompositeClear:
1097             target = kCGBlendModeClear;
1098             break;
1099         case CompositeCopy:
1100             target = kCGBlendModeCopy;
1101             break;
1102         case CompositeSourceOver:
1103             //kCGBlendModeNormal
1104             break;
1105         case CompositeSourceIn:
1106             target = kCGBlendModeSourceIn;
1107             break;
1108         case CompositeSourceOut:
1109             target = kCGBlendModeSourceOut;
1110             break;
1111         case CompositeSourceAtop:
1112             target = kCGBlendModeSourceAtop; 
1113             break;
1114         case CompositeDestinationOver:
1115             target = kCGBlendModeDestinationOver;
1116             break;
1117         case CompositeDestinationIn:
1118             target = kCGBlendModeDestinationIn;
1119             break;
1120         case CompositeDestinationOut:
1121             target = kCGBlendModeDestinationOut;
1122             break;
1123         case CompositeDestinationAtop:
1124             target = kCGBlendModeDestinationAtop;
1125             break;
1126         case CompositeXOR:
1127             target = kCGBlendModeXOR;
1128             break;
1129         case CompositePlusDarker:
1130             target = kCGBlendModePlusDarker;
1131             break;
1132         case CompositeHighlight:
1133             // currently unsupported
1134             break;
1135         case CompositePlusLighter:
1136             target = kCGBlendModePlusLighter;
1137             break;
1138     }
1139     CGContextSetBlendMode(platformContext(), target);
1140 }
1141 #endif
1142
1143 }
1144