19683dffd23b758f73f4506e113381802b4ff5dc
[WebKit-https.git] / Source / WebCore / platform / graphics / wince / GraphicsContextWinCE.cpp
1 /*
2  *  Copyright (C) 2007-2009 Torch Mobile Inc.
3  *  Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Library General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Library General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Library General Public License
16  *  along with this library; see the file COPYING.LIB.  If not, write to
17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  *  Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #include "config.h"
23 #include "GraphicsContext.h"
24
25 #include "AffineTransform.h"
26 #include "Font.h"
27 #include "GDIExtras.h"
28 #include "GlyphBuffer.h"
29 #include "Gradient.h"
30 #include "NotImplemented.h"
31 #include "Path.h"
32 #include "PlatformPathWinCE.h"
33 #include "SharedBitmap.h"
34 #include "SimpleFontData.h"
35 #include <windows.h>
36 #include <wtf/OwnPtr.h>
37 #include <wtf/unicode/CharacterNames.h>
38
39 namespace WebCore {
40
41 typedef void (*FuncGradientFillRectLinear)(HDC hdc, const IntRect& r, const IntPoint& p0, const IntPoint& p1, const Vector<Gradient::ColorStop>& stops);
42 typedef void (*FuncGradientFillRectRadial)(HDC hdc, const IntRect& r, const IntPoint& p0, const IntPoint& p1, float r0, float r1, const Vector<Gradient::ColorStop>& stops);
43 FuncGradientFillRectLinear g_linearGradientFiller = 0;
44 FuncGradientFillRectRadial g_radialGradientFiller = 0;
45
46 static inline bool isZero(double d)
47 {
48     return d > 0 ? d <= 1.E-10 : d >= -1.E-10;
49 }
50
51 // stableRound rounds -0.5 to 0, where lround rounds -0.5 to -1.
52 static inline int stableRound(double d)
53 {
54     if (d > 0)
55         return static_cast<int>(d + 0.5);
56
57     int i = static_cast<int>(d);
58     return i - d > 0.5 ? i - 1 : i;
59 }
60
61 // Unlike enclosingIntRect(), this function does strict rounding.
62 static inline IntRect roundRect(const FloatRect& r)
63 {
64     return IntRect(stableRound(r.x()), stableRound(r.y()), stableRound(r.maxX()) - stableRound(r.x()), stableRound(r.maxY()) - stableRound(r.y()));
65 }
66
67 // Rotation transformation
68 class RotationTransform {
69 public:
70     RotationTransform()
71         : m_cosA(1.)
72         , m_sinA(0.)
73         , m_preShiftX(0)
74         , m_preShiftY(0)
75         , m_postShiftX(0)
76         , m_postShiftY(0)
77     {
78     }
79     RotationTransform operator-() const
80     {
81         RotationTransform rtn;
82         rtn.m_cosA = m_cosA;
83         rtn.m_sinA = -m_sinA;
84         rtn.m_preShiftX = m_postShiftX;
85         rtn.m_preShiftY = m_postShiftY;
86         rtn.m_postShiftX = m_preShiftX;
87         rtn.m_postShiftY = m_preShiftY;
88         return rtn;
89     }
90     void map(double x1, double y1, double* x2, double* y2) const
91     {
92         x1 += m_preShiftX;
93         y1 += m_preShiftY;
94         *x2 = x1 * m_cosA + y1 * m_sinA + m_postShiftX;
95         *y2 = y1 * m_cosA - x1 * m_sinA + m_postShiftY;
96     }
97     void map(int x1, int y1, int* x2, int* y2) const
98     {
99         x1 += m_preShiftX;
100         y1 += m_preShiftY;
101         *x2 = stableRound(x1 * m_cosA + y1 * m_sinA) + m_postShiftX;
102         *y2 = stableRound(y1 * m_cosA - x1 * m_sinA) + m_postShiftY;
103     }
104
105     double m_cosA;
106     double m_sinA;
107     int m_preShiftX;
108     int m_preShiftY;
109     int m_postShiftX;
110     int m_postShiftY;
111 };
112
113 template<class T> static inline IntPoint mapPoint(const IntPoint& p, const T& t)
114 {
115     int x, y;
116     t.map(p.x(), p.y(), &x, &y);
117     return IntPoint(x, y);
118 }
119
120 template<class T> static inline FloatPoint mapPoint(const FloatPoint& p, const T& t)
121 {
122     double x, y;
123     t.map(p.x(), p.y(), &x, &y);
124     return FloatPoint(static_cast<float>(x), static_cast<float>(y));
125 }
126
127 template<class Transform, class Rect, class Value> static inline Rect mapRect(const Rect& rect, const Transform& transform)
128 {
129     Value x[4], y[4];
130     Value l, t, r, b;
131     r = rect.maxX() - 1;
132     b = rect.maxY() - 1;
133     transform.map(rect.x(), rect.y(), x, y);
134     transform.map(rect.x(), b, x + 1, y + 1);
135     transform.map(r, b, x + 2, y + 2);
136     transform.map(r, rect.y(), x + 3, y + 3);
137     l = r = x[3];
138     t = b = y[3];
139     for (int i = 0; i < 3; ++i) {
140         if (x[i] < l)
141             l = x[i];
142         else if (x[i] > r)
143             r = x[i];
144
145         if (y[i] < t)
146             t = y[i];
147         else if (y[i] > b)
148             b = y[i];
149     }
150
151     return IntRect(l, t, r - l + 1, b - t + 1);
152 }
153
154 template<class T> static inline IntRect mapRect(const IntRect& rect, const T& transform)
155 {
156     return mapRect<T, IntRect, int>(rect, transform);
157 }
158
159 template<class T> static inline FloatRect mapRect(const FloatRect& rect, const T& transform)
160 {
161     return mapRect<T, FloatRect, double>(rect, transform);
162 }
163
164 class GraphicsContextPlatformPrivateData {
165 public:
166     GraphicsContextPlatformPrivateData()
167         : m_transform()
168         , m_opacity(1.0)
169     {
170     }
171
172     AffineTransform m_transform;
173     float m_opacity;
174 };
175
176 enum AlphaPaintType {
177     AlphaPaintNone,
178     AlphaPaintImage,
179     AlphaPaintOther,
180 };
181
182 class GraphicsContextPlatformPrivate : public GraphicsContextPlatformPrivateData {
183 public:
184     GraphicsContextPlatformPrivate(HDC dc)
185         : m_dc(dc)
186     {
187     }
188     ~GraphicsContextPlatformPrivate()
189     {
190         while (!m_backupData.isEmpty())
191             restore();
192     }
193
194     void translate(float x, float y)
195     {
196         m_transform.translate(x, y);
197     }
198
199     void scale(const FloatSize& size)
200     {
201         m_transform.scaleNonUniform(size.width(), size.height());
202     }
203
204     void rotate(float radians)
205     {
206         m_transform.rotate(rad2deg(radians));
207     }
208
209     void concatCTM(const AffineTransform& transform)
210     {
211         m_transform *= transform;
212     }
213
214     void setCTM(const AffineTransform& transform)
215     {
216         m_transform = transform;
217     }
218
219     IntRect mapRect(const IntRect& rect) const
220     {
221         return m_transform.mapRect(rect);
222     }
223
224     FloatRect mapRect(const FloatRect& rect) const
225     {
226         return m_transform.mapRect(rect);
227     }
228
229     IntPoint mapPoint(const IntPoint& point) const
230     {
231         return m_transform.mapPoint(point);
232     }
233
234     FloatPoint mapPoint(const FloatPoint& point) const
235     {
236         return m_transform.mapPoint(point);
237     }
238
239     FloatSize mapSize(const FloatSize& size) const
240     {
241         double w, h;
242         m_transform.map(size.width(), size.height(), w, h);
243         return FloatSize(static_cast<float>(w), static_cast<float>(h));
244     }
245
246     void save()
247     {
248         if (m_dc)
249             SaveDC(m_dc);
250
251         m_backupData.append(*static_cast<GraphicsContextPlatformPrivateData*>(this));
252     }
253
254     void restore()
255     {
256         if (m_backupData.isEmpty())
257             return;
258
259         if (m_dc)
260             RestoreDC(m_dc, -1);
261
262         GraphicsContextPlatformPrivateData::operator=(m_backupData.last());
263         m_backupData.removeLast();
264     }
265
266     bool hasAlpha() const { return m_bitmap && m_bitmap->hasAlpha(); }
267
268     PassRefPtr<SharedBitmap> getTransparentLayerBitmap(IntRect& origRect, AlphaPaintType alphaPaint, RECT& bmpRect, bool checkClipBox, bool force) const
269     {
270         if (m_opacity <= 0)
271             return 0;
272
273         if (force || m_opacity < 1.)  {
274             if (checkClipBox) {
275                 RECT clipBox;
276                 int clipType = GetClipBox(m_dc, &clipBox);
277                 if (clipType == SIMPLEREGION || clipType == COMPLEXREGION)
278                     origRect.intersect(clipBox);
279                 if (origRect.isEmpty())
280                     return 0;
281             }
282
283             RefPtr<SharedBitmap> bmp = SharedBitmap::create(origRect.size(), alphaPaint == AlphaPaintNone ? BitmapInfo::BitCount16 : BitmapInfo::BitCount32, false);
284             SetRect(&bmpRect, 0, 0, origRect.width(), origRect.height());
285             if (bmp) {
286                 switch (alphaPaint) {
287                 case AlphaPaintNone:
288                 case AlphaPaintImage:
289                     {
290                         SharedBitmap::DCHolder dc(bmp.get());
291                         if (dc.get()) {
292                             BitBlt(dc.get(), 0, 0, origRect.width(), origRect.height(), m_dc, origRect.x(), origRect.y(), SRCCOPY);
293                             if (bmp->is32bit() && (!m_bitmap || m_bitmap->is16bit())) {
294                                 // Set alpha channel
295                                 unsigned* pixels = (unsigned*)bmp->bytes();
296                                 const unsigned* const pixelsEnd = pixels + bmp->bitmapInfo().numPixels();
297                                 while (pixels < pixelsEnd) {
298                                     *pixels |= 0xFF000000;
299                                     ++pixels;
300                                 }
301                             }
302                             return bmp;
303                         }
304                     }
305                     break;
306                 //case AlphaPaintOther:
307                 default:
308                     memset(bmp->bytes(), 0xFF, bmp->bitmapInfo().numPixels() * 4);
309                     return bmp;
310                     break;
311                 }
312             }
313         }
314
315         bmpRect = origRect;
316         return 0;
317     }
318
319     void paintBackTransparentLayerBitmap(HDC hdc, SharedBitmap* bmp, const IntRect& origRect, AlphaPaintType alphaPaint, const RECT& bmpRect)
320     {
321         if (hdc == m_dc)
322             return;
323
324         if (alphaPaint == AlphaPaintOther && hasAlphaBlendSupport()) {
325             ASSERT(bmp && bmp->bytes() && bmp->is32bit());
326             unsigned* pixels = (unsigned*)bmp->bytes();
327             const unsigned* const pixelsEnd = pixels + bmp->bitmapInfo().numPixels();
328             while (pixels < pixelsEnd) {
329                 *pixels ^= 0xFF000000;
330                 ++pixels;
331             }
332         }
333         if ((m_opacity < 1. || alphaPaint == AlphaPaintOther) && hasAlphaBlendSupport()) {
334             const BLENDFUNCTION blend = { AC_SRC_OVER, 0
335                 , m_opacity >= 1. ? 255 : (BYTE)(m_opacity * 255)
336                 , alphaPaint == AlphaPaintNone ? 0 : AC_SRC_ALPHA };
337             bool success = alphaBlendIfSupported(m_dc, origRect.x(), origRect.y(), origRect.width(), origRect.height(), hdc, 0, 0, bmpRect.right, bmpRect.bottom, blend);
338             ASSERT_UNUSED(success, success);
339         } else
340             StretchBlt(m_dc, origRect.x(), origRect.y(), origRect.width(), origRect.height(), hdc, 0, 0, bmpRect.right, bmpRect.bottom, SRCCOPY);
341     }
342
343     HDC m_dc;
344     RefPtr<SharedBitmap> m_bitmap;
345     Vector<GraphicsContextPlatformPrivateData> m_backupData;
346 };
347
348 static PassOwnPtr<HPEN> createPen(const Color& col, double fWidth, StrokeStyle style)
349 {
350     int width = stableRound(fWidth);
351     if (width < 1)
352         width = 1;
353
354     int penStyle = PS_NULL;
355     switch (style) {
356         case SolidStroke:
357             penStyle = PS_SOLID;
358             break;
359         case DottedStroke:  // not supported on Windows CE
360         case DashedStroke:
361             penStyle = PS_DASH;
362             width = 1;
363             break;
364         default:
365             break;
366     }
367
368     return adoptPtr(CreatePen(penStyle, width, RGB(col.red(), col.green(), col.blue())));
369 }
370
371 static inline PassOwnPtr<HBRUSH> createBrush(const Color& col)
372 {
373     return adoptPtr(CreateSolidBrush(RGB(col.red(), col.green(), col.blue())));
374 }
375
376 template <typename PixelType, bool Is16bit> static void _rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform)
377 {
378     int destW = destBmp->width();
379     int destH = destBmp->height();
380     int sourceW = sourceBmp->width();
381     int sourceH = sourceBmp->height();
382     PixelType* dest = (PixelType*)destBmp->bytes();
383     const PixelType* source = (const PixelType*)sourceBmp->bytes();
384     int padding;
385     int paddedSourceW;
386     if (Is16bit) {
387         padding = destW & 1;
388         paddedSourceW = sourceW + (sourceW & 1);
389     } else {
390         padding = 0;
391         paddedSourceW = sourceW;
392     }
393     if (isZero(transform.m_sinA)) {
394         int cosA = transform.m_cosA > 0 ? 1 : -1;
395         for (int y = 0; y < destH; ++y) {
396             for (int x = 0; x < destW; ++x) {
397                 int x1 = x + transform.m_preShiftX;
398                 int y1 = y + transform.m_preShiftY;
399                 int srcX = x1 * cosA + transform.m_postShiftX;
400                 int srcY = y1 * cosA - transform.m_postShiftY;
401                 if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH)
402                     *dest++ = source[srcY * paddedSourceW + srcX] | 0xFF000000;
403                 else
404                     *dest++ |= 0xFF;
405             }
406             dest += padding;
407         }
408     } else if (isZero(transform.m_cosA)) {
409         int sinA = transform.m_sinA > 0 ? 1 : -1;
410         for (int y = 0; y < destH; ++y) {
411             for (int x = 0; x < destW; ++x) {
412                 int x1 = x + transform.m_preShiftX;
413                 int y1 = y + transform.m_preShiftY;
414                 int srcX = y1 * sinA + transform.m_postShiftX;
415                 int srcY = -x1 * sinA + transform.m_postShiftY;
416                 if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH)
417                     *dest++ = source[srcY * paddedSourceW + srcX];
418             }
419             dest += padding;
420         }
421     } else {
422         for (int y = 0; y < destH; ++y) {
423             for (int x = 0; x < destW; ++x) {
424                 // FIXME: for best quality, we should get weighted sum of four neighbours,
425                 // but that will be too expensive
426                 int srcX, srcY;
427                 transform.map(x, y, &srcX, &srcY);
428                 if (srcX >= 0 && srcX <= sourceW && srcY >= 0 && srcY <= sourceH)
429                     *dest++ = source[srcY * paddedSourceW + srcX];
430             }
431             dest += padding;
432         }
433     }
434 }
435
436 static void rotateBitmap(SharedBitmap* destBmp, const SharedBitmap* sourceBmp, const RotationTransform& transform)
437 {
438     ASSERT(destBmp->is16bit() == sourceBmp->is16bit());
439     if (destBmp->is16bit())
440         _rotateBitmap<unsigned short, true>(destBmp, sourceBmp, transform);
441     else
442         _rotateBitmap<unsigned, false>(destBmp, sourceBmp, transform);
443 }
444
445 class TransparentLayerDC {
446     WTF_MAKE_NONCOPYABLE(TransparentLayerDC);
447 public:
448     TransparentLayerDC(GraphicsContextPlatformPrivate* data, IntRect& origRect, const IntRect* rectBeforeTransform = 0, int alpha = 255, bool paintImage = false);
449     ~TransparentLayerDC();
450
451     HDC hdc() const { return m_memDc; }
452     const RECT& rect() const { return m_bmpRect; }
453     IntSize toShift() const { return IntSize(m_bmpRect.left - m_origRect.x(), m_bmpRect.top - m_origRect.y()); }
454     void fillAlphaChannel();
455
456 private:
457     GraphicsContextPlatformPrivate* m_data;
458     IntRect m_origRect;
459     IntRect m_rotatedOrigRect;
460     HDC m_memDc;
461     RefPtr<SharedBitmap> m_bitmap;
462     RefPtr<SharedBitmap> m_rotatedBitmap;
463     RECT m_bmpRect;
464     unsigned m_key;
465     RotationTransform m_rotation;
466     float m_oldOpacity;
467     AlphaPaintType m_alphaPaintType;
468 };
469
470 TransparentLayerDC::TransparentLayerDC(GraphicsContextPlatformPrivate* data, IntRect& origRect, const IntRect* rectBeforeTransform, int alpha, bool paintImage)
471 : m_data(data)
472 , m_origRect(origRect)
473 , m_oldOpacity(data->m_opacity)
474 // m_key1 and m_key2 are not initalized here. They are used only in the case that
475 // SharedBitmap::getDC() is called, I.E., when m_bitmap is not null.
476 {
477     m_data->m_opacity *= alpha / 255.;
478     bool mustCreateLayer;
479     if (!m_data->hasAlpha()) {
480         mustCreateLayer = false;
481         m_alphaPaintType = AlphaPaintNone;
482     } else {
483         mustCreateLayer = true;
484         m_alphaPaintType = paintImage ? AlphaPaintImage : AlphaPaintOther;
485     }
486     if (rectBeforeTransform && !isZero(m_data->m_transform.b())) {
487         m_rotatedOrigRect = origRect;
488         m_rotatedBitmap = m_data->getTransparentLayerBitmap(m_rotatedOrigRect, m_alphaPaintType, m_bmpRect, false, true);
489         if (m_rotatedBitmap) {
490             double a = m_data->m_transform.a();
491             double b = m_data->m_transform.b();
492             double c = _hypot(a, b);
493             m_rotation.m_cosA = a / c;
494             m_rotation.m_sinA = b / c;
495
496             int centerX = origRect.x() + origRect.width() / 2;
497             int centerY = origRect.y() + origRect.height() / 2;
498             m_rotation.m_preShiftX = -centerX;
499             m_rotation.m_preShiftY = -centerY;
500             m_rotation.m_postShiftX = centerX;
501             m_rotation.m_postShiftY = centerY;
502
503             m_origRect = mapRect(m_rotatedOrigRect, m_rotation);
504
505             m_rotation.m_preShiftX += m_rotatedOrigRect.x();
506             m_rotation.m_preShiftY += m_rotatedOrigRect.y();
507             m_rotation.m_postShiftX -= m_origRect.x();
508             m_rotation.m_postShiftY -= m_origRect.y();
509
510             FloatPoint topLeft = m_data->m_transform.mapPoint(FloatPoint(rectBeforeTransform->location()));
511             FloatPoint topRight(rectBeforeTransform->maxX() - 1, rectBeforeTransform->y());
512             topRight = m_data->m_transform.mapPoint(topRight);
513             FloatPoint bottomLeft(rectBeforeTransform->x(), rectBeforeTransform->maxY() - 1);
514             bottomLeft = m_data->m_transform.mapPoint(bottomLeft);
515             FloatSize sideTop = topRight - topLeft;
516             FloatSize sideLeft = bottomLeft - topLeft;
517             float width = _hypot(sideTop.width() + 1, sideTop.height() + 1);
518             float height = _hypot(sideLeft.width() + 1, sideLeft.height() + 1);
519
520             origRect.inflateX(stableRound((width - origRect.width()) * 0.5));
521             origRect.inflateY(stableRound((height - origRect.height()) * 0.5));
522
523             m_bitmap = SharedBitmap::create(m_origRect.size(), m_rotatedBitmap->is16bit() ? BitmapInfo::BitCount16 : BitmapInfo::BitCount32, true);
524             if (m_bitmap)
525                 rotateBitmap(m_bitmap.get(), m_rotatedBitmap.get(), -m_rotation);
526             else
527                 m_rotatedBitmap = 0;
528         }
529     } else
530         m_bitmap = m_data->getTransparentLayerBitmap(m_origRect, m_alphaPaintType, m_bmpRect, true, mustCreateLayer);
531     if (m_bitmap)
532         m_memDc = m_bitmap->getDC(&m_key);
533     else
534         m_memDc = m_data->m_dc;
535 }
536
537 TransparentLayerDC::~TransparentLayerDC()
538 {
539     if (m_rotatedBitmap) {
540         m_bitmap->releaseDC(m_memDc, m_key);
541         m_key = 0;
542         rotateBitmap(m_rotatedBitmap.get(), m_bitmap.get(), m_rotation);
543         m_memDc = m_rotatedBitmap->getDC(&m_key);
544         m_data->paintBackTransparentLayerBitmap(m_memDc, m_rotatedBitmap.get(), m_rotatedOrigRect, m_alphaPaintType, m_bmpRect);
545         m_rotatedBitmap->releaseDC(m_memDc, m_key);
546     } else if (m_bitmap) {
547         m_data->paintBackTransparentLayerBitmap(m_memDc, m_bitmap.get(), m_origRect, m_alphaPaintType, m_bmpRect);
548         m_bitmap->releaseDC(m_memDc, m_key);
549     }
550     m_data->m_opacity = m_oldOpacity;
551 }
552
553 void TransparentLayerDC::fillAlphaChannel()
554 {
555     if (!m_bitmap || !m_bitmap->is32bit())
556         return;
557
558     unsigned* pixels = (unsigned*)m_bitmap->bytes();
559     const unsigned* const pixelsEnd = pixels + m_bitmap->bitmapInfo().numPixels();
560     while (pixels < pixelsEnd) {
561         *pixels |= 0xFF000000;
562         ++pixels;
563     }
564 }
565
566 class ScopeDCProvider {
567     WTF_MAKE_NONCOPYABLE(ScopeDCProvider);
568 public:
569     explicit ScopeDCProvider(GraphicsContextPlatformPrivate* data)
570         : m_data(data)
571     {
572         if (m_data->m_bitmap)
573             m_data->m_dc = m_data->m_bitmap->getDC(&m_key);
574     }
575     ~ScopeDCProvider()
576     {
577         if (m_data->m_bitmap) {
578             m_data->m_bitmap->releaseDC(m_data->m_dc, m_key);
579             m_data->m_dc = 0;
580         }
581     }
582 private:
583     GraphicsContextPlatformPrivate* m_data;
584     unsigned m_key;
585 };
586
587
588 void GraphicsContext::platformInit(PlatformGraphicsContext* dc)
589 {
590     m_data = new GraphicsContextPlatformPrivate(dc);
591 }
592
593 void GraphicsContext::platformDestroy()
594 {
595     delete m_data;
596 }
597
598 void GraphicsContext::setBitmap(PassRefPtr<SharedBitmap> bmp)
599 {
600     ASSERT(!m_data->m_dc);
601     m_data->m_bitmap = bmp;
602 }
603
604 HDC GraphicsContext::getWindowsContext(const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
605 {
606     // FIXME: Add support for AlphaBlend.
607     ASSERT(!supportAlphaBlend);
608     return m_data->m_dc;
609 }
610
611 void GraphicsContext::releaseWindowsContext(HDC hdc, const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
612 {
613 }
614
615 void GraphicsContext::savePlatformState()
616 {
617     m_data->save();
618 }
619
620 void GraphicsContext::restorePlatformState()
621 {
622     m_data->restore();
623 }
624
625 void GraphicsContext::drawRect(const IntRect& rect)
626 {
627     if (!m_data->m_opacity || paintingDisabled() || rect.isEmpty())
628         return;
629
630     ScopeDCProvider dcProvider(m_data);
631     if (!m_data->m_dc)
632         return;
633
634     IntRect trRect = m_data->mapRect(rect);
635     TransparentLayerDC transparentDC(m_data, trRect, &rect);
636     HDC dc = transparentDC.hdc();
637     if (!dc)
638         return;
639     trRect.move(transparentDC.toShift());
640
641     OwnPtr<HBRUSH> brush;
642     HGDIOBJ oldBrush;
643     if (fillColor().alpha()) {
644         brush = createBrush(fillColor());
645         oldBrush = SelectObject(dc, brush.get());
646     } else
647         oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
648
649     OwnPtr<HPEN> pen;
650     HGDIOBJ oldPen;
651     if (strokeStyle() != NoStroke) {
652         pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
653         oldPen = SelectObject(dc, pen.get());
654     } else
655         oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
656
657     if (brush || pen) {
658         if (trRect.width() <= 0)
659             trRect.setWidth(1);
660         if (trRect.height() <= 0)
661             trRect.setHeight(1);
662
663         Rectangle(dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
664     }
665
666     SelectObject(dc, oldPen);
667     SelectObject(dc, oldBrush);
668 }
669
670 void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
671 {
672     if (!m_data->m_opacity || paintingDisabled() || strokeStyle() == NoStroke || !strokeColor().alpha())
673         return;
674
675     ScopeDCProvider dcProvider(m_data);
676     if (!m_data->m_dc)
677         return;
678
679     IntPoint trPoint1 = m_data->mapPoint(point1);
680     IntPoint trPoint2 = m_data->mapPoint(point2);
681
682     IntRect lineRect(trPoint1, trPoint2 - trPoint1);
683     lineRect.setHeight(lineRect.height() + strokeThickness());
684     TransparentLayerDC transparentDC(m_data, lineRect, 0, strokeColor().alpha());
685     HDC dc = transparentDC.hdc();
686     if (!dc)
687         return;
688     trPoint1 += transparentDC.toShift();
689     trPoint2 += transparentDC.toShift();
690
691     OwnPtr<HPEN> pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
692     HGDIOBJ oldPen = SelectObject(dc, pen.get());
693
694     MoveToEx(dc, trPoint1.x(), trPoint1.y(), 0);
695     LineTo(dc, trPoint2.x(), trPoint2.y());
696
697     SelectObject(dc, oldPen);
698 }
699
700 void GraphicsContext::drawEllipse(const IntRect& rect)
701 {
702     if (!m_data->m_opacity || paintingDisabled() || (!fillColor().alpha() && strokeStyle() == NoStroke))
703         return;
704
705     ScopeDCProvider dcProvider(m_data);
706     if (!m_data->m_dc)
707         return;
708
709     IntRect trRect = m_data->mapRect(rect);
710     TransparentLayerDC transparentDC(m_data, trRect, &rect);
711     HDC dc = transparentDC.hdc();
712     if (!dc)
713         return;
714     trRect.move(transparentDC.toShift());
715
716     OwnPtr<HBRUSH> brush;
717     HGDIOBJ oldBrush;
718     if (fillColor().alpha()) {
719         brush = createBrush(fillColor());
720         oldBrush = SelectObject(dc, brush.get());
721     } else
722         oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
723
724     OwnPtr<HPEN> pen;
725     HGDIOBJ oldPen = 0;
726     if (strokeStyle() != NoStroke) {
727         pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
728         oldPen = SelectObject(dc, pen.get());
729     } else
730         oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
731
732     if (brush || pen)
733         Ellipse(dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
734
735     SelectObject(dc, oldPen);
736     SelectObject(dc, oldBrush);
737 }
738
739 static inline bool equalAngle(double a, double b) 
740 {
741     return fabs(a - b) < 1E-5;
742 }
743
744 void getEllipsePointByAngle(double angle, double a, double b, float& x, float& y)
745 {
746     while (angle < 0)
747         angle += 2 * piDouble;
748     while (angle >= 2 * piDouble)
749         angle -= 2 * piDouble;
750
751     if (equalAngle(angle, 0) || equalAngle(angle, 2 * piDouble)) {
752         x = a;
753         y = 0;
754     } else if (equalAngle(angle, piDouble)) {
755         x = -a;
756         y = 0;
757     } else if (equalAngle(angle, .5 * piDouble)) {
758         x = 0;
759         y = b;
760     } else if (equalAngle(angle, 1.5 * piDouble)) {
761         x = 0;
762         y = -b;
763     } else {
764         double k = tan(angle);
765         double sqA = a * a;
766         double sqB = b * b;
767         double tmp = 1. / (1. / sqA + (k * k) / sqB);
768         tmp = tmp <= 0 ? 0 : sqrt(tmp);
769         if (angle > .5 * piDouble && angle < 1.5 * piDouble)
770             tmp = -tmp;
771         x = tmp;
772
773         k = tan(.5 * piDouble - angle);
774         tmp = 1. / ((k * k) / sqA + 1 / sqB);
775         tmp = tmp <= 0 ? 0 : sqrt(tmp);
776         if (angle > piDouble)
777             tmp = -tmp;
778         y = tmp;
779     }
780 }
781
782 void GraphicsContext::strokeArc(const IntRect& rect, int startAngle, int angleSpan)
783 {
784     if (!m_data->m_opacity || paintingDisabled() || strokeStyle() == NoStroke || rect.isEmpty())
785         return;
786
787     ScopeDCProvider dcProvider(m_data);
788     if (!m_data->m_dc)
789         return;
790
791     IntRect trRect = m_data->mapRect(rect);
792     TransparentLayerDC transparentDC(m_data, trRect, &rect);
793     HDC dc = transparentDC.hdc();
794     if (!dc)
795         return;
796     trRect.move(transparentDC.toShift());
797
798     OwnPtr<HPEN> pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
799     HGDIOBJ oldPen = SelectObject(dc, pen.get());
800
801     double a = trRect.width() * 0.5;
802     double b = trRect.height() * 0.5;
803     int centerX = stableRound(trRect.x() + a);
804     int centerY = stableRound(trRect.y() + b);
805     float fstartX, fstartY, fendX, fendY;
806     int startX, startY, endX, endY;
807     getEllipsePointByAngle(deg2rad((double)startAngle), a, b, fstartX, fstartY);
808     getEllipsePointByAngle(deg2rad((double)startAngle + angleSpan), a, b, fendX, fendY);
809     startX = stableRound(fstartX);
810     startY = stableRound(fstartY);
811     endX = stableRound(fendX);
812     endY = stableRound(fendY);
813
814     startX += centerX;
815     startY = centerY - startY;
816     endX += centerX;
817     endY = centerY - endY;
818     RECT clipRect;
819     if (startX < endX) {
820         clipRect.left = startX;
821         clipRect.right = endX;
822     } else {
823         clipRect.left = endX;
824         clipRect.right = startX;
825     }
826     if (startY < endY) {
827         clipRect.top = startY;
828         clipRect.bottom = endY;
829     } else {
830         clipRect.top = endY;
831         clipRect.bottom = startY;
832     }
833
834     OwnPtr<HRGN> clipRgn(CreateRectRgn(0, 0, 0, 0));
835     bool newClip;
836     if (GetClipRgn(dc, clipRgn.get()) <= 0) {
837         newClip = true;
838         clipRgn.set(CreateRectRgn(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom));
839         SelectClipRgn(dc, clipRgn.get());
840     } else {
841         newClip = false;
842         IntersectClipRect(dc, clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
843     }
844
845     HGDIOBJ oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
846     Ellipse(dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
847     SelectObject(dc, oldBrush);
848
849     if (newClip)
850         SelectClipRgn(dc, 0);
851     else
852         SelectClipRgn(dc, clipRgn.get());
853
854     SelectObject(dc, oldPen);
855 }
856
857 void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias)
858 {
859     if (!m_data->m_opacity || paintingDisabled() || npoints <= 1 || !points)
860         return;
861
862     ScopeDCProvider dcProvider(m_data);
863     if (!m_data->m_dc)
864         return;
865
866     Vector<POINT, 20> winPoints(npoints);
867     FloatPoint trPoint = m_data->mapPoint(points[0]);
868     winPoints[0].x = stableRound(trPoint.x());
869     winPoints[0].y = stableRound(trPoint.y());
870     RECT rect = { winPoints[0].x, winPoints[0].y, winPoints[0].x, winPoints[0].y };
871     for (size_t i = 1; i < npoints; ++i) {
872         trPoint = m_data->mapPoint(points[i]);
873         winPoints[i].x = stableRound(trPoint.x());
874         winPoints[i].y = stableRound(trPoint.y());
875         if (rect.left > winPoints[i].x)
876             rect.left = winPoints[i].x;
877         else if (rect.right < winPoints[i].x)
878             rect.right = winPoints[i].x;
879         if (rect.top > winPoints[i].y)
880             rect.top = winPoints[i].y;
881         else if (rect.bottom < winPoints[i].y)
882             rect.bottom = winPoints[i].y;
883     }
884     rect.bottom += 1;
885     rect.right += 1;
886
887     IntRect intRect(rect);
888     TransparentLayerDC transparentDC(m_data, intRect);
889     HDC dc = transparentDC.hdc();
890     if (!dc)
891         return;
892
893     for (size_t i = 0; i < npoints; ++i) {
894         winPoints[i].x += transparentDC.toShift().width();
895         winPoints[i].y += transparentDC.toShift().height();
896     }
897
898     OwnPtr<HBRUSH> brush;
899     HGDIOBJ oldBrush;
900     if (fillColor().alpha()) {
901         brush = createBrush(fillColor());
902         oldBrush = SelectObject(dc, brush.get());
903     } else
904         oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH));
905
906     OwnPtr<HPEN> pen;
907     HGDIOBJ oldPen;
908     if (strokeStyle() != NoStroke) {
909         pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
910         oldPen = SelectObject(dc, pen.get());
911     } else
912         oldPen = SelectObject(dc, GetStockObject(NULL_PEN));
913
914     if (brush || pen)
915         Polygon(dc, winPoints.data(), npoints);
916
917     SelectObject(dc, oldPen);
918     SelectObject(dc, oldBrush);
919 }
920
921 void GraphicsContext::clipConvexPolygon(size_t numPoints, const FloatPoint* points, bool antialiased)
922 {
923     if (paintingDisabled())
924         return;
925
926     if (numPoints <= 1)
927         return;
928     
929     // FIXME: IMPLEMENT!!
930 }
931
932 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, ColorSpace colorSpace)
933 {
934     if (paintingDisabled() || !m_data->m_opacity)
935         return;
936
937     int alpha = color.alpha();
938     if (!alpha)
939         return;
940
941     ScopeDCProvider dcProvider(m_data);
942     if (!m_data->m_dc)
943         return;
944
945     IntRect intRect = enclosingIntRect(rect);
946     TransparentLayerDC transparentDC(m_data, m_data->mapRect(intRect), &intRect, alpha);
947
948     if (!transparentDC.hdc())
949         return;
950
951     OwnPtr<HBRUSH> hbrush(CreateSolidBrush(RGB(color.red(), color.green(), color.blue())));
952     FillRect(transparentDC.hdc(), &transparentDC.rect(), hbrush.get());
953 }
954
955 void GraphicsContext::clip(const FloatRect& rect)
956 {
957     if (paintingDisabled())
958         return;
959
960     if (!m_data->m_dc)
961         return;
962
963     IntRect trRect = enclosingIntRect(m_data->mapRect(rect));
964
965     OwnPtr<HRGN> clipRgn(CreateRectRgn(0, 0, 0, 0));
966     if (GetClipRgn(m_data->m_dc, clipRgn.get()) > 0)
967         IntersectClipRect(m_data->m_dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
968     else {
969         clipRgn.set(CreateRectRgn(trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY()));
970         SelectClipRgn(m_data->m_dc, clipRgn.get());
971     }
972 }
973
974 void GraphicsContext::clipOut(const IntRect& rect)
975 {
976     if (paintingDisabled())
977         return;
978
979     if (!m_data->m_dc)
980         return;
981
982     IntRect trRect = m_data->mapRect(rect);
983
984     ExcludeClipRect(m_data->m_dc, trRect.x(), trRect.y(), trRect.maxX(), trRect.maxY());
985 }
986
987 void GraphicsContext::drawFocusRing(const Path& path, int width, int offset, const Color& color)
988 {
989     // FIXME: implement
990 }
991
992 void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int width, int offset, const Color& color)
993 {
994     if (!m_data->m_opacity || paintingDisabled())
995         return;
996
997     ScopeDCProvider dcProvider(m_data);
998     if (!m_data->m_dc)
999         return;
1000
1001     int radius = (width - 1) / 2;
1002     offset += radius;
1003
1004     unsigned rectCount = rects.size();
1005     IntRect finalFocusRect;
1006     for (unsigned i = 0; i < rectCount; i++) {
1007         IntRect focusRect = rects[i];
1008         focusRect.inflate(offset);
1009         finalFocusRect.unite(focusRect);
1010     }
1011
1012     IntRect intRect = finalFocusRect;
1013     IntRect trRect = m_data->mapRect(finalFocusRect);
1014     TransparentLayerDC transparentDC(m_data, trRect, &intRect);
1015     HDC dc = transparentDC.hdc();
1016     if (!dc)
1017         return;
1018     trRect.move(transparentDC.toShift());
1019
1020     RECT rect = trRect;
1021     DrawFocusRect(dc, &rect);
1022 }
1023
1024 void GraphicsContext::drawLineForText(const FloatPoint& origin, float width, bool printing)
1025 {
1026     if (paintingDisabled())
1027         return;
1028
1029     StrokeStyle oldStyle = strokeStyle();
1030     setStrokeStyle(SolidStroke);
1031     drawLine(roundedIntPoint(origin), roundedIntPoint(origin + FloatSize(width, 0)));
1032     setStrokeStyle(oldStyle);
1033 }
1034
1035 void GraphicsContext::drawLineForTextChecking(const FloatPoint&, float width, TextCheckingLineStyle style)
1036 {
1037     notImplemented();
1038 }
1039
1040 void GraphicsContext::setPlatformFillColor(const Color& col, ColorSpace colorSpace)
1041 {
1042     notImplemented();
1043 }
1044
1045 void GraphicsContext::setPlatformStrokeColor(const Color& col, ColorSpace colorSpace)
1046 {
1047     notImplemented();
1048 }
1049
1050 void GraphicsContext::setPlatformStrokeThickness(float strokeThickness)
1051 {
1052     notImplemented();
1053 }
1054
1055 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
1056 {
1057     notImplemented();
1058 }
1059
1060 void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness)
1061 {
1062     // We can only clip rectangles on WINCE
1063     clip(rect);
1064 }
1065
1066 void GraphicsContext::clearRect(const FloatRect& rect)
1067 {
1068     if (paintingDisabled())
1069         return;
1070
1071     if (m_data->hasAlpha()) {
1072         IntRect trRect = enclosingIntRect(m_data->mapRect(rect));
1073         m_data->m_bitmap->clearPixels(trRect);
1074         return;
1075     } 
1076
1077     fillRect(rect, Color(Color::white), ColorSpaceDeviceRGB);
1078 }
1079
1080 void GraphicsContext::strokeRect(const FloatRect& rect, float width)
1081 {
1082     if (!m_data->m_opacity || paintingDisabled() || strokeStyle() == NoStroke)
1083         return;
1084
1085     ScopeDCProvider dcProvider(m_data);
1086     if (!m_data->m_dc)
1087         return;
1088
1089     IntRect intRect = enclosingIntRect(rect);
1090     IntRect trRect = m_data->mapRect(intRect);
1091     TransparentLayerDC transparentDC(m_data, trRect, &intRect);
1092     HDC dc = transparentDC.hdc();
1093     if (!dc)
1094         return;
1095     trRect.move(transparentDC.toShift());
1096
1097     OwnPtr<HPEN> pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
1098     HGDIOBJ oldPen = SelectObject(dc, pen.get());
1099
1100     int right = trRect.maxX() - 1;
1101     int bottom = trRect.maxY() - 1;
1102     const POINT intPoints[5] =
1103     {
1104         { trRect.x(), trRect.y() },
1105         { right, trRect.y() },
1106         { right, bottom },
1107         { trRect.x(), bottom },
1108         { trRect.x(), trRect.y() }
1109     };
1110
1111     Polyline(dc, intPoints, 5);
1112
1113     SelectObject(dc, oldPen);
1114 }
1115
1116 void GraphicsContext::beginTransparencyLayer(float opacity)
1117 {
1118     m_data->save();
1119     m_data->m_opacity *= opacity;
1120 }
1121
1122 void GraphicsContext::endTransparencyLayer()
1123 {
1124     m_data->restore();
1125 }
1126
1127 void GraphicsContext::concatCTM(const AffineTransform& transform)
1128 {
1129     m_data->concatCTM(transform);
1130 }
1131
1132 void GraphicsContext::setCTM(const AffineTransform& transform)
1133 {
1134     m_data->setCTM(transform);
1135 }
1136
1137 AffineTransform& GraphicsContext::affineTransform()
1138 {
1139     return m_data->m_transform;
1140 }
1141
1142 const AffineTransform& GraphicsContext::affineTransform() const
1143 {
1144     return m_data->m_transform;
1145 }
1146
1147 void GraphicsContext::resetAffineTransform()
1148 {
1149     m_data->m_transform.makeIdentity();
1150 }
1151
1152 void GraphicsContext::translate(float x, float y)
1153 {
1154     m_data->translate(x, y);
1155 }
1156
1157 void GraphicsContext::rotate(float radians)
1158 {
1159     m_data->rotate(radians);
1160 }
1161
1162 void GraphicsContext::scale(const FloatSize& size)
1163 {
1164     m_data->scale(size);
1165 }
1166
1167 void GraphicsContext::setLineCap(LineCap lineCap)
1168 {
1169     notImplemented();
1170 }
1171
1172 void GraphicsContext::setLineJoin(LineJoin lineJoin)
1173 {
1174     notImplemented();
1175 }
1176
1177 void GraphicsContext::setMiterLimit(float miter)
1178 {
1179     notImplemented();
1180 }
1181
1182 void GraphicsContext::setAlpha(float alpha)
1183 {
1184     m_data->m_opacity = alpha;
1185 }
1186
1187 void GraphicsContext::setPlatformCompositeOperation(CompositeOperator op)
1188 {
1189     notImplemented();
1190 }
1191
1192 void GraphicsContext::clip(const Path& path)
1193 {
1194     notImplemented();
1195 }
1196
1197 void GraphicsContext::canvasClip(const Path& path)
1198 {
1199     clip(path);
1200 }
1201
1202 void GraphicsContext::clipOut(const Path&)
1203 {
1204     notImplemented();
1205 }
1206
1207 static inline IntPoint rectCenterPoint(const RECT& rect)
1208 {
1209     return IntPoint(rect.left + (rect.right - rect.left) / 2, rect.top + (rect.bottom - rect.top) / 2);
1210 }
1211 void GraphicsContext::fillRoundedRect(const IntRect& fillRect, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color& c, ColorSpace colorSpace)
1212 {
1213     ScopeDCProvider dcProvider(m_data);
1214     if (!m_data->m_dc)
1215         return;
1216
1217     FloatSize shadowOffset;
1218     float shadowBlur = 0;
1219     Color shadowColor;
1220     ColorSpace shadowColorSpace;
1221         
1222     getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace);
1223     
1224     IntRect dstRect = fillRect;
1225     
1226     dstRect.move(stableRound(shadowOffset.width()), stableRound(shadowOffset.height()));
1227     dstRect.inflate(stableRound(shadowBlur));
1228     dstRect = m_data->mapRect(dstRect);
1229   
1230     FloatSize newTopLeft(m_data->mapSize(topLeft));
1231     FloatSize newTopRight(m_data->mapSize(topRight));
1232     FloatSize newBottomLeft(m_data->mapSize(bottomLeft));
1233     FloatSize newBottomRight(m_data->mapSize(bottomRight));
1234
1235     TransparentLayerDC transparentDc(m_data, dstRect, &fillRect);
1236     HDC dc = transparentDc.hdc();
1237     if (!dc)
1238         return;
1239
1240     dstRect.move(transparentDc.toShift());
1241
1242     RECT rectWin = dstRect;
1243
1244     OwnPtr<HBRUSH> brush = createBrush(shadowColor);
1245     HGDIOBJ oldBrush = SelectObject(dc, brush.get());
1246
1247     SelectObject(dc, GetStockObject(NULL_PEN));
1248
1249     IntPoint centerPoint = rectCenterPoint(rectWin);
1250     // Draw top left half
1251     RECT clipRect(rectWin);
1252     clipRect.right = centerPoint.x();
1253     clipRect.bottom = centerPoint.y();
1254
1255     OwnPtr<HRGN> clipRgn(CreateRectRgn(0, 0, 0, 0));
1256     bool needsNewClip = (GetClipRgn(dc, clipRgn.get()) <= 0);
1257     
1258     drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newTopLeft.width() * 2), stableRound(newTopLeft.height() * 2));
1259
1260     // Draw top right
1261     clipRect = rectWin;
1262     clipRect.left = centerPoint.x();
1263     clipRect.bottom = centerPoint.y();
1264
1265     drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newTopRight.width() * 2), stableRound(newTopRight.height() * 2));
1266
1267      // Draw bottom left
1268     clipRect = rectWin;
1269     clipRect.right = centerPoint.x();
1270     clipRect.top = centerPoint.y();
1271
1272     drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newBottomLeft.width() * 2), stableRound(newBottomLeft.height() * 2));
1273
1274     // Draw bottom right
1275     clipRect = rectWin;
1276     clipRect.left = centerPoint.x();
1277     clipRect.top = centerPoint.y();
1278
1279     drawRoundCorner(needsNewClip, clipRect, rectWin, dc, stableRound(newBottomRight.width() * 2), stableRound(newBottomRight.height() * 2));
1280
1281     SelectObject(dc, oldBrush);
1282 }
1283
1284
1285 void GraphicsContext::drawRoundCorner(bool needsNewClip, RECT clipRect, RECT rectWin, HDC dc, int width, int height)
1286 {
1287     if (!dc)
1288         return;
1289
1290     OwnPtr<HRGN> clipRgn(CreateRectRgn(0, 0, 0, 0));
1291     if (needsNewClip)  {
1292         clipRgn.set(CreateRectRgn(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom));
1293         SelectClipRgn(dc, clipRgn.get());
1294     } else 
1295         IntersectClipRect(dc, clipRect.left, clipRect.top, clipRect.right, clipRect.bottom);
1296     
1297     ::RoundRect(dc, rectWin.left , rectWin.top , rectWin.right , rectWin.bottom , width, height);
1298     
1299     SelectClipRgn(dc, needsNewClip ? 0 : clipRgn.get());
1300 }
1301
1302
1303 FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& frect)
1304 {
1305     notImplemented();
1306     return frect;
1307 }
1308
1309 Color gradientAverageColor(const Gradient* gradient)
1310 {
1311     const Vector<Gradient::ColorStop>& stops = gradient->getStops();
1312     if (stops.isEmpty())
1313         return Color();
1314
1315     const Gradient::ColorStop& stop = stops.first();
1316     if (stops.size() == 1)
1317         return Color(stop.red, stop.green, stop.blue, stop.alpha);
1318
1319     const Gradient::ColorStop& lastStop = stops.last();
1320     return Color((stop.red + lastStop.red) * 0.5f
1321         , (stop.green + lastStop.green) * 0.5f
1322         , (stop.blue + lastStop.blue) * 0.5f
1323         , (stop.alpha + lastStop.alpha) * 0.5f);
1324 }
1325
1326 void GraphicsContext::fillPath(const Path& path)
1327 {
1328     Color c = m_state.fillGradient
1329         ? gradientAverageColor(m_state.fillGradient.get())
1330         : fillColor();
1331
1332     if (!c.alpha() || !m_data->m_opacity)
1333         return;
1334
1335     ScopeDCProvider dcProvider(m_data);
1336     if (!m_data->m_dc)
1337         return;
1338
1339     OwnPtr<HBRUSH> brush = createBrush(c);
1340
1341     if (m_data->m_opacity < 1.0f || m_data->hasAlpha()) {
1342         IntRect trRect = enclosingIntRect(m_data->mapRect(path.boundingRect()));
1343         trRect.inflate(1);
1344         TransparentLayerDC transparentDC(m_data, trRect);
1345         HDC dc = transparentDC.hdc();
1346         if (!dc)
1347             return;
1348
1349         AffineTransform tr = m_data->m_transform;
1350         tr.translate(transparentDC.toShift().width(), transparentDC.toShift().height());
1351
1352         SelectObject(dc, GetStockObject(NULL_PEN));
1353         HGDIOBJ oldBrush = SelectObject(dc, brush.get());
1354         path.platformPath()->fillPath(dc, &tr);
1355         SelectObject(dc, oldBrush);
1356     } else {
1357         SelectObject(m_data->m_dc, GetStockObject(NULL_PEN));
1358         HGDIOBJ oldBrush = SelectObject(m_data->m_dc, brush.get());
1359         path.platformPath()->fillPath(m_data->m_dc, &m_data->m_transform);
1360         SelectObject(m_data->m_dc, oldBrush);
1361     }
1362 }
1363
1364
1365 void GraphicsContext::strokePath(const Path& path)
1366 {
1367     if (!m_data->m_opacity)
1368         return;
1369
1370     ScopeDCProvider dcProvider(m_data);
1371     if (!m_data->m_dc)
1372         return;
1373
1374     OwnPtr<HPEN> pen = createPen(strokeColor(), strokeThickness(), strokeStyle());
1375
1376     if (m_data->m_opacity < 1.0f || m_data->hasAlpha()) {
1377         IntRect trRect = enclosingIntRect(m_data->mapRect(path.boundingRect()));
1378         trRect.inflate(1);
1379         TransparentLayerDC transparentDC(m_data, trRect);
1380         HDC dc = transparentDC.hdc();
1381         if (!dc)
1382             return;
1383
1384         AffineTransform tr = m_data->m_transform;
1385         tr.translate(transparentDC.toShift().width(), transparentDC.toShift().height());
1386
1387         SelectObject(dc, GetStockObject(NULL_BRUSH));
1388         HGDIOBJ oldPen = SelectObject(dc, pen.get());
1389         path.platformPath()->strokePath(dc, &tr);
1390         SelectObject(dc, oldPen);
1391     } else {
1392         SelectObject(m_data->m_dc, GetStockObject(NULL_BRUSH));
1393         HGDIOBJ oldPen = SelectObject(m_data->m_dc, pen.get());
1394         path.platformPath()->strokePath(m_data->m_dc, &m_data->m_transform);
1395         SelectObject(m_data->m_dc, oldPen);
1396     }
1397 }
1398
1399 void GraphicsContext::fillRect(const FloatRect& r, const Gradient* gradient)
1400 {
1401     if (!m_data->m_opacity)
1402         return;
1403
1404     const Vector<Gradient::ColorStop>& stops = gradient->getStops();
1405     if (stops.isEmpty())
1406         return;
1407
1408     size_t numStops = stops.size();
1409     if (numStops == 1) {
1410         const Gradient::ColorStop& stop = stops.first();
1411         Color color(stop.red, stop.green, stop.blue, stop.alpha);
1412         fillRect(r, color, ColorSpaceDeviceRGB);
1413         return;
1414     } 
1415     
1416     ScopeDCProvider dcProvider(m_data);
1417     if (!m_data->m_dc)
1418         return;
1419
1420     IntRect intRect = enclosingIntRect(r);
1421     IntRect rect = m_data->mapRect(intRect);
1422     TransparentLayerDC transparentDC(m_data, rect, &intRect, 255, true);
1423     HDC dc = transparentDC.hdc();
1424     if (!dc)
1425         return;
1426
1427     rect.move(transparentDC.toShift());
1428     FloatPoint fp0 = m_data->mapPoint(gradient->p0());
1429     FloatPoint fp1 = m_data->mapPoint(gradient->p1());
1430     IntPoint p0(stableRound(fp0.x()), stableRound(fp0.y()));
1431     IntPoint p1(stableRound(fp1.x()), stableRound(fp1.y()));
1432     p0 += transparentDC.toShift();
1433     p1 += transparentDC.toShift();
1434
1435     if (gradient->isRadial()) {
1436         if (g_radialGradientFiller) {
1437             // FIXME: don't support 2D scaling at this time
1438             double scale = (m_data->m_transform.a() + m_data->m_transform.d()) * 0.5;
1439             float r0 = gradient->startRadius() * scale;
1440             float r1 = gradient->endRadius() * scale;
1441             g_radialGradientFiller(dc, rect, p0, p1, r0, r1, gradient->getStops());
1442             return;
1443         }
1444     } else if (g_linearGradientFiller) {
1445         g_linearGradientFiller(dc, rect, p0, p1, gradient->getStops());
1446         return;
1447     }
1448
1449     // Simple 1D linear solution that assumes p0 is on the top or left side, and p1 is on the right or bottom side
1450     size_t numRects = (numStops - 1);
1451     Vector<TRIVERTEX, 20> tv;
1452     tv.resize(numRects * 2);
1453     Vector<GRADIENT_RECT, 10> mesh;
1454     mesh.resize(numRects);
1455     int x = rect.x();
1456     int y = rect.y();
1457     int width = rect.width();
1458     int height = rect.height();
1459     FloatSize d = gradient->p1() - gradient->p0();
1460     bool vertical = fabs(d.height()) > fabs(d.width());
1461     for (size_t i = 0; i < numStops; ++i) {
1462         const Gradient::ColorStop& stop = stops[i];
1463         int iTv = i ? 2 * i - 1 : 0;
1464         tv[iTv].Red = stop.red * 0xFFFF;
1465         tv[iTv].Green = stop.green * 0xFFFF;
1466         tv[iTv].Blue = stop.blue * 0xFFFF;
1467         tv[iTv].Alpha = stop.alpha * 0xFFFF;
1468         if (i) {
1469             tv[iTv].x = vertical ? x + width: x + width * stop.stop;
1470             tv[iTv].y = vertical ? y + height * stop.stop : y + height;
1471             mesh[i - 1].UpperLeft = iTv - 1;
1472             mesh[i - 1].LowerRight = iTv;
1473         } else {
1474             tv[iTv].x = x;
1475             tv[iTv].y = y;
1476         }
1477
1478         if (i && i < numRects) {
1479             tv[iTv + 1] = tv[iTv];
1480             if (vertical)
1481                 tv[iTv + 1].x = x;
1482             else
1483                 tv[iTv + 1].y = y;
1484         }
1485     }
1486
1487     GradientFill(dc, tv.data(), tv.size(), mesh.data(), mesh.size(), vertical ? GRADIENT_FILL_RECT_V : GRADIENT_FILL_RECT_H);
1488 }
1489
1490 AffineTransform GraphicsContext::getCTM() const
1491 {
1492     return m_data->m_transform;
1493 }
1494
1495 void GraphicsContext::fillRect(const FloatRect& rect)
1496 {
1497     savePlatformState();
1498
1499     if (m_state.fillGradient)
1500         fillRect(rect, m_state.fillGradient.get());
1501     else
1502         fillRect(rect, fillColor(), ColorSpaceDeviceRGB);
1503
1504     restorePlatformState();
1505 }
1506
1507 void GraphicsContext::setPlatformShadow(const FloatSize&, float, const Color&, ColorSpace)
1508 {
1509     notImplemented();
1510 }
1511
1512 void GraphicsContext::clearPlatformShadow()
1513 {
1514     notImplemented();
1515 }
1516
1517 InterpolationQuality GraphicsContext::imageInterpolationQuality() const
1518 {
1519     notImplemented();
1520     return InterpolationDefault;
1521 }
1522
1523 void GraphicsContext::setImageInterpolationQuality(InterpolationQuality)
1524 {
1525     notImplemented();
1526 }
1527
1528 static inline bool isCharVisible(UChar c)
1529 {
1530     return c && c != zeroWidthSpace;
1531 }
1532
1533 void GraphicsContext::drawText(const Font& font, const TextRun& run, const FloatPoint& point, int from, int to)
1534 {
1535     if (paintingDisabled() || !fillColor().alpha() || !m_data->m_opacity)
1536         return;
1537
1538     bool mustSupportAlpha = m_data->hasAlpha();
1539
1540     if (!mustSupportAlpha && fillColor().alpha() == 0xFF && m_data->m_opacity >= 1.0) {
1541         font.drawText(this, run, point, from, to);
1542         return;
1543     }
1544
1545     float oldOpacity = m_data->m_opacity;
1546     m_data->m_opacity *= fillColor().alpha() / 255.0;
1547
1548     FloatRect textRect = font.selectionRectForText(run, point, font.fontMetrics().height(), from, to);
1549     textRect.setY(textRect.y() - font.fontMetrics().ascent());
1550     IntRect trRect = enclosingIntRect(m_data->mapRect(textRect));
1551     RECT bmpRect;
1552     AlphaPaintType alphaPaintType = mustSupportAlpha ? AlphaPaintOther : AlphaPaintNone;
1553     if (RefPtr<SharedBitmap> bmp = m_data->getTransparentLayerBitmap(trRect, alphaPaintType, bmpRect, true, mustSupportAlpha)) {
1554         {
1555             GraphicsContext gc(0);
1556             gc.setBitmap(bmp);
1557             gc.scale(FloatSize(m_data->m_transform.a(), m_data->m_transform.d()));
1558             font.drawText(&gc, run, IntPoint(0, font.fontMetrics().ascent()), from, to);
1559         }
1560         unsigned key1;
1561         HDC memDC = bmp->getDC(&key1);
1562         if (memDC) {
1563             m_data->paintBackTransparentLayerBitmap(memDC, bmp.get(), trRect, alphaPaintType, bmpRect);
1564             bmp->releaseDC(memDC, key1);
1565         }
1566     }
1567
1568     m_data->m_opacity = oldOpacity;
1569 }
1570
1571 void GraphicsContext::drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer,
1572                       int from, int numGlyphs, const FloatPoint& point)
1573 {
1574     if (!m_data->m_opacity)
1575         return;
1576
1577     for (;;) {
1578         if (!numGlyphs)
1579             return;
1580         if (isCharVisible(*glyphBuffer.glyphs(from)))
1581             break;
1582         ++from;
1583         --numGlyphs;
1584     }
1585
1586     double scaleX = m_data->m_transform.a();
1587     double scaleY = m_data->m_transform.d();
1588
1589     int height = fontData->platformData().size() * scaleY;
1590     int width = fontData->platformData().averageCharWidth() * scaleX;
1591
1592     if (!height || !width)
1593         return;
1594
1595     ScopeDCProvider dcProvider(m_data);
1596     if (!m_data->m_dc)
1597         return;
1598
1599     HFONT hFont = height > 1
1600         ? fontData->platformData().getScaledFontHandle(height, scaleX == scaleY ? 0 : width)
1601         : 0;
1602
1603     FloatPoint startPoint(point.x(), point.y() - fontData->fontMetrics().ascent());
1604     FloatPoint trPoint = m_data->mapPoint(startPoint);
1605     int y = stableRound(trPoint.y());
1606
1607     Color color = fillColor();
1608     if (!color.alpha())
1609         return;
1610
1611     COLORREF fontColor = RGB(color.red(), color.green(), color.blue());
1612
1613     if (!hFont) {
1614         double offset = trPoint.x();
1615         const GlyphBufferAdvance* advance = glyphBuffer.advances(from);
1616         if (scaleX == 1.)
1617             for (int i = 1; i < numGlyphs; ++i)
1618                 offset += *advance++;
1619         else
1620             for (int i = 1; i < numGlyphs; ++i)
1621                 offset += *advance++ * scaleX;
1622
1623         offset += width;
1624
1625         OwnPtr<HPEN> hPen(CreatePen(PS_DASH, 1, fontColor));
1626         HGDIOBJ oldPen = SelectObject(m_data->m_dc, hPen.get());
1627
1628         MoveToEx(m_data->m_dc, stableRound(trPoint.x()), y, 0);
1629         LineTo(m_data->m_dc, stableRound(offset), y);
1630
1631         SelectObject(m_data->m_dc, oldPen);
1632         return;
1633     }
1634
1635     FloatSize shadowOffset;
1636     float shadowBlur = 0;
1637     Color shadowColor;
1638     ColorSpace shadowColorSpace;
1639     bool hasShadow = textDrawingMode() == TextModeFill
1640         && getShadow(shadowOffset, shadowBlur, shadowColor, shadowColorSpace)
1641         && shadowColor.alpha();
1642     COLORREF shadowRGBColor;
1643     FloatPoint trShadowPoint;
1644     if (hasShadow) {
1645         shadowRGBColor = RGB(shadowColor.red(), shadowColor.green(), shadowColor.blue());
1646         trShadowPoint = m_data->mapPoint(startPoint + shadowOffset);
1647     }
1648
1649     HGDIOBJ hOldFont = SelectObject(m_data->m_dc, hFont);
1650     COLORREF oldTextColor = GetTextColor(m_data->m_dc);
1651     int oldTextAlign = GetTextAlign(m_data->m_dc);
1652     SetTextAlign(m_data->m_dc, 0);
1653
1654     int oldBkMode = GetBkMode(m_data->m_dc);
1655     SetBkMode(m_data->m_dc, TRANSPARENT);
1656
1657     if (numGlyphs > 1) {
1658         double offset = trPoint.x();
1659         Vector<int, 256> glyphSpace(numGlyphs);
1660         Vector<UChar, 256> text(numGlyphs);
1661         int* curSpace = glyphSpace.data();
1662         UChar* curChar = text.data();
1663         const UChar* srcChar = glyphBuffer.glyphs(from);
1664         const UChar* const srcCharEnd = srcChar + numGlyphs;
1665         *curChar++ = *srcChar++;
1666         int firstOffset = stableRound(offset);
1667         int lastOffset = firstOffset;
1668         const GlyphBufferAdvance* advance = glyphBuffer.advances(from);
1669         // FIXME: ExtTextOut() can flip over each word for RTL languages, even when TA_RTLREADING is off.
1670         // (this can be GDI bug or font driver bug?)
1671         // We are not clear how it processes characters and handles specified spaces. On the other side,
1672         // our glyph buffer is already in the correct order for rendering. So, the solution is that we
1673         // call ExtTextOut() for each single character when the text contains any RTL character.
1674         // This solution is not perfect as it is slower than calling ExtTextOut() one time for all characters.
1675         // Drawing characters one by one may be too slow.
1676         bool drawOneByOne = false;
1677         if (scaleX == 1.) {
1678             for (; srcChar < srcCharEnd; ++srcChar) {
1679                 offset += *advance++;
1680                 int offsetInt = stableRound(offset);
1681                 if (isCharVisible(*srcChar)) {
1682                     if (!drawOneByOne && WTF::Unicode::direction(*srcChar) == WTF::Unicode::RightToLeft)
1683                         drawOneByOne = true;
1684                     *curChar++ = *srcChar;
1685                     *curSpace++ = offsetInt - lastOffset;
1686                     lastOffset = offsetInt;
1687                 }
1688             }
1689         } else {
1690             for (; srcChar < srcCharEnd; ++srcChar) {
1691                 offset += *advance++ * scaleX;
1692                 int offsetInt = stableRound(offset);
1693                 if (isCharVisible(*srcChar)) {
1694                     if (!drawOneByOne && WTF::Unicode::direction(*srcChar) == WTF::Unicode::RightToLeft)
1695                         drawOneByOne = true;
1696                     *curChar++ = *srcChar;
1697                     *curSpace++ = offsetInt - lastOffset;
1698                     lastOffset = offsetInt;
1699                 }
1700             }
1701         }
1702         numGlyphs = curChar - text.data();
1703         if (hasShadow) {
1704             SetTextColor(m_data->m_dc, shadowRGBColor);
1705             if (drawOneByOne) {
1706                 int xShadow = firstOffset + stableRound(trShadowPoint.x() - trPoint.x());
1707                 int yShadow = stableRound(trShadowPoint.y());
1708                 for (int i = 0; i < numGlyphs; ++i) {
1709                     ExtTextOut(m_data->m_dc, xShadow, yShadow, 0, NULL, text.data() + i, 1, 0);
1710                     xShadow += glyphSpace[i];
1711                 }
1712             } else
1713                 ExtTextOut(m_data->m_dc, firstOffset + stableRound(trShadowPoint.x() - trPoint.x()), stableRound(trShadowPoint.y()), 0, NULL, text.data(), numGlyphs, glyphSpace.data());
1714         }
1715         SetTextColor(m_data->m_dc, fontColor);
1716         if (drawOneByOne) {
1717             int x = firstOffset;
1718             for (int i = 0; i < numGlyphs; ++i) {
1719                 ExtTextOut(m_data->m_dc, x, y, 0, NULL, text.data() + i, 1, 0);
1720                 x += glyphSpace[i];
1721             }
1722         } else
1723             ExtTextOut(m_data->m_dc, firstOffset, y, 0, NULL, text.data(), numGlyphs, glyphSpace.data());
1724     } else {
1725         UChar c = *glyphBuffer.glyphs(from);
1726         if (hasShadow) {
1727             SetTextColor(m_data->m_dc, shadowRGBColor);
1728             ExtTextOut(m_data->m_dc, stableRound(trShadowPoint.x()), stableRound(trShadowPoint.y()), 0, NULL, &c, 1, 0);
1729         }
1730         SetTextColor(m_data->m_dc, fontColor);
1731         ExtTextOut(m_data->m_dc, stableRound(trPoint.x()), y, 0, NULL, &c, 1, 0);
1732     }
1733
1734     SetTextAlign(m_data->m_dc, oldTextAlign);
1735     SetTextColor(m_data->m_dc, oldTextColor);
1736     SetBkMode(m_data->m_dc, oldBkMode);
1737     SelectObject(m_data->m_dc, hOldFont);
1738 }
1739
1740 void GraphicsContext::drawFrameControl(const IntRect& rect, unsigned type, unsigned state)
1741 {
1742     if (!m_data->m_opacity)
1743         return;
1744
1745     const int boxWidthBest = 8;
1746     const int boxHeightBest = 8;
1747
1748     ScopeDCProvider dcProvider(m_data);
1749     if (!m_data->m_dc)
1750         return;
1751
1752     IntRect trRect = m_data->mapRect(rect);
1753     TransparentLayerDC transparentDC(m_data, trRect, &rect, 255, true);
1754     HDC dc = transparentDC.hdc();
1755     if (!dc)
1756         return;
1757     trRect.move(transparentDC.toShift());
1758
1759     RECT rectWin = trRect;
1760
1761     if ((rectWin.right - rectWin.left) < boxWidthBest) {
1762         RefPtr<SharedBitmap> bmp = SharedBitmap::create(IntSize(boxWidthBest, boxHeightBest), BitmapInfo::BitCount16, true);
1763         SharedBitmap::DCHolder memDC(bmp.get());
1764         if (memDC.get()) {
1765             RECT tempRect = {0, 0, boxWidthBest, boxHeightBest};
1766             DrawFrameControl(memDC.get(), &tempRect, type, state);
1767
1768             ::StretchBlt(dc, rectWin.left, rectWin.top, rectWin.right - rectWin.left, rectWin.bottom - rectWin.top, memDC.get(), 0, 0, boxWidthBest, boxHeightBest, SRCCOPY);
1769             return;
1770         }
1771     }
1772
1773     DrawFrameControl(dc, &rectWin, type, state);
1774 }
1775
1776 void GraphicsContext::drawFocusRect(const IntRect& rect)
1777 {
1778     if (!m_data->m_opacity)
1779         return;
1780
1781     ScopeDCProvider dcProvider(m_data);
1782     if (!m_data->m_dc)
1783         return;
1784
1785     IntRect trRect = m_data->mapRect(rect);
1786     TransparentLayerDC transparentDC(m_data, trRect, &rect);
1787     HDC dc = transparentDC.hdc();
1788     if (!dc)
1789         return;
1790     trRect.move(transparentDC.toShift());
1791
1792     RECT rectWin = trRect;
1793     DrawFocusRect(dc, &rectWin);
1794 }
1795
1796 void GraphicsContext::paintTextField(const IntRect& rect, unsigned state)
1797 {
1798     if (!m_data->m_opacity)
1799         return;
1800
1801     ScopeDCProvider dcProvider(m_data);
1802     if (!m_data->m_dc)
1803         return;
1804
1805     IntRect trRect = m_data->mapRect(rect);
1806     TransparentLayerDC transparentDC(m_data, trRect, &rect);
1807     HDC dc = transparentDC.hdc();
1808     if (!dc)
1809         return;
1810     trRect.move(transparentDC.toShift());
1811
1812     RECT rectWin = trRect;
1813     DrawEdge(dc, &rectWin, EDGE_ETCHED, BF_RECT | BF_ADJUST);
1814     FillRect(dc, &rectWin, reinterpret_cast<HBRUSH>(((state & DFCS_INACTIVE) ? COLOR_BTNFACE : COLOR_WINDOW) + 1));
1815 }
1816
1817 void GraphicsContext::drawBitmap(SharedBitmap* bmp, const IntRect& dstRectIn, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp)
1818 {
1819     if (!m_data->m_opacity)
1820         return;
1821
1822     ScopeDCProvider dcProvider(m_data);
1823     if (!m_data->m_dc)
1824         return;
1825
1826     IntRect dstRect = m_data->mapRect(dstRectIn);
1827     TransparentLayerDC transparentDC(m_data, dstRect, &dstRectIn, 255, true);
1828     HDC dc = transparentDC.hdc();
1829     if (!dc)
1830         return;
1831     dstRect.move(transparentDC.toShift());
1832
1833     bmp->draw(dc, dstRect, srcRect, compositeOp);
1834
1835     if (bmp->is16bit())
1836         transparentDC.fillAlphaChannel();
1837 }
1838
1839 void GraphicsContext::drawBitmapPattern(SharedBitmap* bmp, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
1840                 const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRectIn, const IntSize& origSourceSize)
1841 {
1842     if (!m_data->m_opacity)
1843         return;
1844
1845     ScopeDCProvider dcProvider(m_data);
1846     if (!m_data->m_dc)
1847         return;
1848
1849     IntRect intDstRect = enclosingIntRect(destRectIn);
1850     IntRect trRect = m_data->mapRect(intDstRect);
1851     TransparentLayerDC transparentDC(m_data, trRect, &intDstRect, 255, true);
1852     HDC dc = transparentDC.hdc();
1853     if (!dc)
1854         return;
1855     trRect.move(transparentDC.toShift());
1856     FloatRect movedDstRect = m_data->m_transform.inverse().mapRect(FloatRect(trRect));
1857     FloatSize moved(movedDstRect.location() - destRectIn.location());
1858     AffineTransform transform = m_data->m_transform;
1859     transform.translate(moved.width(), moved.height());
1860
1861     bmp->drawPattern(dc, transform, tileRectIn, patternTransform, phase, styleColorSpace, op, destRectIn, origSourceSize);
1862
1863     if (!bmp->hasAlpha())
1864         transparentDC.fillAlphaChannel();
1865 }
1866
1867 void GraphicsContext::drawIcon(HICON icon, const IntRect& dstRectIn, UINT flags)
1868 {
1869     if (!m_data->m_opacity)
1870         return;
1871
1872     ScopeDCProvider dcProvider(m_data);
1873     if (!m_data->m_dc)
1874         return;
1875
1876     IntRect dstRect = m_data->mapRect(dstRectIn);
1877     TransparentLayerDC transparentDC(m_data, dstRect, &dstRectIn, 255, true);
1878     HDC dc = transparentDC.hdc();
1879     if (!dc)
1880         return;
1881     dstRect.move(transparentDC.toShift());
1882
1883     DrawIconEx(dc, dstRect.x(), dstRect.y(), icon, dstRect.width(), dstRect.height(), 0, NULL, flags);
1884 }
1885
1886 void GraphicsContext::setPlatformShouldAntialias(bool)
1887 {
1888     notImplemented();
1889 }
1890
1891 void GraphicsContext::setLineDash(const DashArray&, float)
1892 {
1893     notImplemented();
1894 }
1895
1896 void GraphicsContext::clipPath(const Path&, WindRule)
1897 {
1898     notImplemented();
1899 }
1900
1901 } // namespace WebCore