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