| /* |
| * Copyright (C) 2006 Apple Computer, Inc. All rights reserved. |
| * Copyright (C) 2007 Alp Toker <alp@atoker.com> |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "GraphicsContext.h" |
| |
| #if PLATFORM(CAIRO) |
| |
| #include "CairoPath.h" |
| #include "FloatRect.h" |
| #include "Font.h" |
| #include "FontData.h" |
| #include "IntRect.h" |
| #include "NotImplemented.h" |
| #include "Path.h" |
| #include <cairo.h> |
| #include <math.h> |
| #include <stdio.h> |
| #include <wtf/MathExtras.h> |
| |
| #if PLATFORM(WIN) |
| #include <cairo-win32.h> |
| #endif |
| |
| #if PLATFORM(GTK) |
| #include <gdk/gdk.h> |
| #endif |
| |
| |
| #ifndef M_PI |
| #define M_PI 3.14159265358979323846 |
| #endif |
| |
| namespace WebCore { |
| |
| class GraphicsContextPlatformPrivate { |
| public: |
| GraphicsContextPlatformPrivate(); |
| ~GraphicsContextPlatformPrivate(); |
| |
| cairo_t* cr; |
| Vector<float> layers; |
| |
| #if PLATFORM(GTK) |
| GdkEventExpose* expose; |
| #endif |
| }; |
| |
| static inline void setColor(cairo_t* cr, const Color& col) |
| { |
| float red, green, blue, alpha; |
| col.getRGBA(red, green, blue, alpha); |
| cairo_set_source_rgba(cr, red, green, blue, alpha); |
| } |
| |
| // A fillRect helper |
| static inline void fillRectSourceOver(cairo_t* cr, const FloatRect& rect, const Color& col) |
| { |
| setColor(cr, col); |
| cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height()); |
| cairo_set_operator(cr, CAIRO_OPERATOR_OVER); |
| cairo_fill(cr); |
| } |
| |
| GraphicsContextPlatformPrivate::GraphicsContextPlatformPrivate() |
| : cr(0) |
| #if PLATFORM(GTK) |
| , expose(0) |
| #endif |
| { |
| } |
| |
| GraphicsContextPlatformPrivate::~GraphicsContextPlatformPrivate() |
| { |
| cairo_destroy(cr); |
| } |
| |
| #if PLATFORM(WIN) |
| GraphicsContext::GraphicsContext(HDC dc) |
| : m_common(createGraphicsContextPrivate()) |
| , m_data(new GraphicsContextPlatformPrivate) |
| { |
| if (dc) { |
| cairo_surface_t* surface = cairo_win32_surface_create(dc); |
| m_data->cr = cairo_create(surface); |
| } else { |
| setPaintingDisabled(true); |
| m_data->cr = 0; |
| } |
| } |
| #endif |
| |
| GraphicsContext::GraphicsContext(PlatformGraphicsContext* cr) |
| : m_common(createGraphicsContextPrivate()) |
| , m_data(new GraphicsContextPlatformPrivate) |
| { |
| m_data->cr = cairo_reference(cr); |
| setPaintingDisabled(!cr); |
| } |
| |
| GraphicsContext::~GraphicsContext() |
| { |
| destroyGraphicsContextPrivate(m_common); |
| delete m_data; |
| } |
| |
| cairo_t* GraphicsContext::platformContext() const |
| { |
| return m_data->cr; |
| } |
| |
| void GraphicsContext::savePlatformState() |
| { |
| cairo_save(m_data->cr); |
| } |
| |
| void GraphicsContext::restorePlatformState() |
| { |
| cairo_restore(m_data->cr); |
| } |
| |
| // Draws a filled rectangle with a stroked border. |
| void GraphicsContext::drawRect(const IntRect& rect) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_save(cr); |
| |
| if (fillColor().alpha()) |
| fillRectSourceOver(cr, rect, fillColor()); |
| |
| if (strokeStyle() != NoStroke) { |
| setColor(cr, strokeColor()); |
| FloatRect r(rect); |
| r.inflate(-.5f); |
| cairo_rectangle(cr, r.x(), r.y(), r.width(), r.height()); |
| cairo_set_line_width(cr, 1.0); |
| cairo_stroke(cr); |
| } |
| |
| cairo_restore(cr); |
| } |
| |
| // FIXME: Now that this is refactored, it should be shared by all contexts. |
| static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle style) |
| { |
| // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic |
| // works out. For example, with a border width of 3, KHTML will pass us (y1+y2)/2, e.g., |
| // (50+53)/2 = 103/2 = 51 when we want 51.5. It is always true that an even width gave |
| // us a perfect position, but an odd width gave us a position that is off by exactly 0.5. |
| if (style == DottedStroke || style == DashedStroke) { |
| if (p1.x() == p2.x()) { |
| p1.setY(p1.y() + strokeWidth); |
| p2.setY(p2.y() - strokeWidth); |
| } |
| else { |
| p1.setX(p1.x() + strokeWidth); |
| p2.setX(p2.x() - strokeWidth); |
| } |
| } |
| |
| if (static_cast<int>(strokeWidth) % 2) { |
| if (p1.x() == p2.x()) { |
| // We're a vertical line. Adjust our x. |
| p1.setX(p1.x() + 0.5); |
| p2.setX(p2.x() + 0.5); |
| } |
| else { |
| // We're a horizontal line. Adjust our y. |
| p1.setY(p1.y() + 0.5); |
| p2.setY(p2.y() + 0.5); |
| } |
| } |
| } |
| |
| // This is only used to draw borders. |
| void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| StrokeStyle style = strokeStyle(); |
| if (style == NoStroke) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_save(cr); |
| |
| float width = strokeThickness(); |
| if (width < 1) |
| width = 1; |
| |
| FloatPoint p1 = point1; |
| FloatPoint p2 = point2; |
| bool isVerticalLine = (p1.x() == p2.x()); |
| |
| adjustLineToPixelBoundaries(p1, p2, width, style); |
| cairo_set_line_width(cr, width); |
| |
| int patWidth = 0; |
| switch (style) { |
| case NoStroke: |
| case SolidStroke: |
| break; |
| case DottedStroke: |
| patWidth = static_cast<int>(width); |
| break; |
| case DashedStroke: |
| patWidth = 3*static_cast<int>(width); |
| break; |
| } |
| |
| setColor(cr, strokeColor()); |
| |
| cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE); |
| |
| if (patWidth) { |
| // Do a rect fill of our endpoints. This ensures we always have the |
| // appearance of being a border. We then draw the actual dotted/dashed line. |
| if (isVerticalLine) { |
| fillRectSourceOver(cr, FloatRect(p1.x() - width/2, p1.y() - width, width, width), strokeColor()); |
| fillRectSourceOver(cr, FloatRect(p2.x() - width/2, p2.y(), width, width), strokeColor()); |
| } else { |
| fillRectSourceOver(cr, FloatRect(p1.x() - width, p1.y() - width/2, width, width), strokeColor()); |
| fillRectSourceOver(cr, FloatRect(p2.x(), p2.y() - width/2, width, width), strokeColor()); |
| } |
| |
| // Example: 80 pixels with a width of 30 pixels. |
| // Remainder is 20. The maximum pixels of line we could paint |
| // will be 50 pixels. |
| int distance = (isVerticalLine ? (point2.y() - point1.y()) : (point2.x() - point1.x())) - 2*static_cast<int>(width); |
| int remainder = distance%patWidth; |
| int coverage = distance-remainder; |
| int numSegments = coverage/patWidth; |
| |
| float patternOffset = 0; |
| // Special case 1px dotted borders for speed. |
| if (patWidth == 1) |
| patternOffset = 1.0; |
| else { |
| bool evenNumberOfSegments = numSegments%2 == 0; |
| if (remainder) |
| evenNumberOfSegments = !evenNumberOfSegments; |
| if (evenNumberOfSegments) { |
| if (remainder) { |
| patternOffset += patWidth - remainder; |
| patternOffset += remainder/2; |
| } |
| else |
| patternOffset = patWidth/2; |
| } |
| else if (!evenNumberOfSegments) { |
| if (remainder) |
| patternOffset = (patWidth - remainder)/2; |
| } |
| } |
| |
| double dash = patWidth; |
| cairo_set_dash(cr, &dash, 1, patternOffset); |
| } |
| |
| cairo_move_to(cr, p1.x(), p1.y()); |
| cairo_line_to(cr, p2.x(), p2.y()); |
| |
| cairo_stroke(cr); |
| cairo_restore(cr); |
| } |
| |
| // This method is only used to draw the little circles used in lists. |
| void GraphicsContext::drawEllipse(const IntRect& rect) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_save(cr); |
| float yRadius = .5 * rect.height(); |
| float xRadius = .5 * rect.width(); |
| cairo_translate(cr, rect.x() + xRadius, rect.y() + yRadius); |
| cairo_scale(cr, xRadius, yRadius); |
| cairo_arc(cr, 0., 0., 1., 0., 2 * M_PI); |
| cairo_restore(cr); |
| |
| if (fillColor().alpha()) { |
| setColor(cr, fillColor()); |
| cairo_fill_preserve(cr); |
| } |
| |
| if (strokeStyle() != NoStroke) { |
| setColor(cr, strokeColor()); |
| cairo_set_line_width(cr, strokeThickness()); |
| cairo_stroke(cr); |
| } |
| |
| cairo_new_path(cr); |
| } |
| |
| // FIXME: This function needs to be adjusted to match the functionality on the Mac side. |
| void GraphicsContext::strokeArc(const IntRect& rect, int startAngle, int angleSpan) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| if (strokeStyle() == NoStroke) |
| return; |
| |
| int x = rect.x(); |
| int y = rect.y(); |
| float w = rect.width(); |
| #if 0 // FIXME: unused so far |
| float h = rect.height(); |
| float scaleFactor = h / w; |
| float reverseScaleFactor = w / h; |
| #endif |
| float r = w / 2; |
| float fa = startAngle; |
| float falen = fa + angleSpan; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_save(cr); |
| cairo_arc_negative(cr, x + r, y + r, r, -fa * M_PI/180, -falen * M_PI/180); |
| setColor(cr, strokeColor()); |
| cairo_set_line_width(cr, strokeThickness()); |
| cairo_stroke(cr); |
| cairo_restore(cr); |
| } |
| |
| void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| if (npoints <= 1) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| |
| cairo_save(cr); |
| cairo_set_antialias(cr, shouldAntialias ? CAIRO_ANTIALIAS_DEFAULT : CAIRO_ANTIALIAS_NONE); |
| cairo_move_to(cr, points[0].x(), points[0].y()); |
| for (size_t i = 1; i < npoints; i++) |
| cairo_line_to(cr, points[i].x(), points[i].y()); |
| cairo_close_path(cr); |
| |
| if (fillColor().alpha()) { |
| setColor(cr, fillColor()); |
| cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD); |
| cairo_fill_preserve(cr); |
| } |
| |
| if (strokeStyle() != NoStroke) { |
| setColor(cr, strokeColor()); |
| cairo_set_line_width(cr, strokeThickness()); |
| cairo_stroke(cr); |
| } |
| |
| cairo_new_path(cr); |
| cairo_restore(cr); |
| } |
| |
| void GraphicsContext::fillRect(const IntRect& rect, const Color& color) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| if (color.alpha()) |
| fillRectSourceOver(m_data->cr, rect, color); |
| } |
| |
| void GraphicsContext::fillRect(const FloatRect& rect, const Color& color) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| if (color.alpha()) |
| fillRectSourceOver(m_data->cr, rect, color); |
| } |
| |
| void GraphicsContext::clip(const IntRect& rect) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height()); |
| cairo_clip(cr); |
| } |
| |
| void GraphicsContext::drawFocusRing(const Color& color) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| int radius = (focusRingWidth() - 1) / 2; |
| int offset = radius + focusRingOffset(); |
| |
| const Vector<IntRect>& rects = focusRingRects(); |
| unsigned rectCount = rects.size(); |
| IntRect finalFocusRect; |
| for (unsigned i = 0; i < rectCount; i++) { |
| IntRect focusRect = rects[i]; |
| focusRect.inflate(offset); |
| finalFocusRect.unite(focusRect); |
| } |
| |
| cairo_t* cr = m_data->cr; |
| cairo_save(cr); |
| // FIXME: These rects should be rounded |
| cairo_rectangle(cr, finalFocusRect.x(), finalFocusRect.y(), finalFocusRect.width(), finalFocusRect.height()); |
| |
| // Force the alpha to 50%. This matches what the Mac does with outline rings. |
| Color ringColor(color.red(), color.green(), color.blue(), 127); |
| setColor(cr, ringColor); |
| cairo_stroke(cr); |
| cairo_restore(cr); |
| } |
| |
| void GraphicsContext::setFocusRingClip(const IntRect&) |
| { |
| // hopefully a no-op. Comment in CG version says that it exists |
| // to work around bugs in Mac focus ring clipping |
| } |
| |
| void GraphicsContext::clearFocusRingClip() |
| { |
| // hopefully a no-op. Comment in CG version says that it exists |
| // to work around bugs in Mac focus ring clipping |
| } |
| |
| void GraphicsContext::drawLineForText(const IntPoint& origin, int width, bool printing) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| IntPoint endPoint = origin + IntSize(width, 0); |
| drawLine(origin, endPoint); |
| } |
| |
| void GraphicsContext::drawLineForMisspellingOrBadGrammar(const IntPoint&, int width, bool grammar) |
| { |
| notImplemented(); |
| } |
| |
| FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& frect) |
| { |
| FloatRect result; |
| double x = frect.x(); |
| double y = frect.y(); |
| cairo_t* cr = m_data->cr; |
| cairo_user_to_device(cr, &x, &y); |
| x = round(x); |
| y = round(y); |
| cairo_device_to_user(cr, &x, &y); |
| result.setX(static_cast<float>(x)); |
| result.setY(static_cast<float>(y)); |
| x = frect.width(); |
| y = frect.height(); |
| cairo_user_to_device_distance(cr, &x, &y); |
| x = round(x); |
| y = round(y); |
| cairo_device_to_user_distance(cr, &x, &y); |
| result.setWidth(static_cast<float>(x)); |
| result.setHeight(static_cast<float>(y)); |
| return result; |
| } |
| |
| void GraphicsContext::translate(float x, float y) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_translate(cr, x, y); |
| } |
| |
| IntPoint GraphicsContext::origin() |
| { |
| cairo_matrix_t matrix; |
| cairo_t* cr = m_data->cr; |
| cairo_get_matrix(cr, &matrix); |
| return IntPoint(static_cast<int>(matrix.x0), static_cast<int>(matrix.y0)); |
| } |
| |
| void GraphicsContext::setPlatformFillColor(const Color& col) |
| { |
| // FIXME: this is probably a no-op but I'm not sure |
| // notImplemented(); // commented-out because it's chatty and clutters output |
| } |
| |
| void GraphicsContext::setPlatformStrokeColor(const Color& col) |
| { |
| // FIXME: this is probably a no-op but I'm not sure |
| //notImplemented(); // commented-out because it's chatty and clutters output |
| } |
| |
| void GraphicsContext::setPlatformStrokeThickness(float strokeThickness) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_set_line_width(m_data->cr, strokeThickness); |
| } |
| |
| void GraphicsContext::setPlatformStrokeStyle(const StrokeStyle& strokeStyle) |
| { |
| static double dashPattern[] = {5.0, 5.0}; |
| static double dotPattern[] = {1.0, 1.0}; |
| |
| if (paintingDisabled()) |
| return; |
| |
| switch (strokeStyle) { |
| case NoStroke: |
| // FIXME: is it the right way to emulate NoStroke? |
| cairo_set_line_width(m_data->cr, 0); |
| break; |
| case SolidStroke: |
| cairo_set_dash(m_data->cr, 0, 0, 0); |
| break; |
| case DottedStroke: |
| cairo_set_dash(m_data->cr, dotPattern, 2, 0); |
| break; |
| case DashedStroke: |
| cairo_set_dash(m_data->cr, dashPattern, 2, 0); |
| break; |
| default: |
| notImplemented(); |
| break; |
| } |
| } |
| |
| void GraphicsContext::setPlatformFont(const Font& font) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| #if PLATFORM(GTK) |
| // FIXME: is it the right thing to do? Also, doesn't work on Win because |
| // there FontData doesn't have ::setFont() |
| const FontData *fontData = font.primaryFont(); |
| fontData->setFont(m_data->cr); |
| #endif |
| } |
| |
| void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::concatCTM(const AffineTransform& transform) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| const cairo_matrix_t* matrix = reinterpret_cast<const cairo_matrix_t*>(&transform); |
| cairo_transform(cr, matrix); |
| } |
| |
| void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::setShadow(IntSize const&, int, Color const&) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::clearShadow() |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::beginTransparencyLayer(float opacity) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_push_group(cr); |
| m_data->layers.append(opacity); |
| } |
| |
| void GraphicsContext::endTransparencyLayer() |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| |
| cairo_pop_group_to_source(cr); |
| cairo_paint_with_alpha(cr, m_data->layers.last()); |
| m_data->layers.removeLast(); |
| } |
| |
| void GraphicsContext::clearRect(const FloatRect& rect) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| |
| cairo_save(cr); |
| cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height()); |
| cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); |
| cairo_fill(cr); |
| cairo_restore(cr); |
| } |
| |
| void GraphicsContext::strokeRect(const FloatRect&, float) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::setLineCap(LineCap lineCap) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_line_cap_t cairoCap = CAIRO_LINE_CAP_BUTT; |
| switch (lineCap) { |
| case ButtCap: |
| // no-op |
| break; |
| case RoundCap: |
| cairoCap = CAIRO_LINE_CAP_ROUND; |
| break; |
| case SquareCap: |
| cairoCap = CAIRO_LINE_CAP_SQUARE; |
| break; |
| } |
| cairo_set_line_cap(m_data->cr, cairoCap); |
| } |
| |
| void GraphicsContext::setLineJoin(LineJoin lineJoin) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_line_join_t cairoJoin = CAIRO_LINE_JOIN_MITER; |
| switch (lineJoin) { |
| case MiterJoin: |
| // no-op |
| break; |
| case RoundJoin: |
| cairoJoin = CAIRO_LINE_JOIN_ROUND; |
| break; |
| case BevelJoin: |
| cairoJoin = CAIRO_LINE_JOIN_BEVEL; |
| break; |
| } |
| cairo_set_line_join(m_data->cr, cairoJoin); |
| } |
| |
| void GraphicsContext::setMiterLimit(float miter) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_set_miter_limit(m_data->cr, miter); |
| } |
| |
| void GraphicsContext::setAlpha(float) |
| { |
| notImplemented(); |
| } |
| |
| static inline cairo_operator_t toCairoOperator(CompositeOperator op) |
| { |
| switch (op) { |
| case CompositeClear: |
| return CAIRO_OPERATOR_CLEAR; |
| case CompositeCopy: |
| return CAIRO_OPERATOR_SOURCE; |
| case CompositeSourceOver: |
| return CAIRO_OPERATOR_OVER; |
| case CompositeSourceIn: |
| return CAIRO_OPERATOR_IN; |
| case CompositeSourceOut: |
| return CAIRO_OPERATOR_OUT; |
| case CompositeSourceAtop: |
| return CAIRO_OPERATOR_ATOP; |
| case CompositeDestinationOver: |
| return CAIRO_OPERATOR_DEST_OVER; |
| case CompositeDestinationIn: |
| return CAIRO_OPERATOR_DEST_IN; |
| case CompositeDestinationOut: |
| return CAIRO_OPERATOR_DEST_OUT; |
| case CompositeDestinationAtop: |
| return CAIRO_OPERATOR_DEST_ATOP; |
| case CompositeXOR: |
| return CAIRO_OPERATOR_XOR; |
| case CompositePlusDarker: |
| return CAIRO_OPERATOR_OVER; |
| case CompositeHighlight: |
| return CAIRO_OPERATOR_OVER; |
| case CompositePlusLighter: |
| return CAIRO_OPERATOR_OVER; |
| } |
| |
| return CAIRO_OPERATOR_OVER; |
| } |
| |
| void GraphicsContext::setCompositeOperation(CompositeOperator op) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_set_operator(m_data->cr, toCairoOperator(op)); |
| } |
| |
| void GraphicsContext::beginPath() |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_new_path(cr); |
| } |
| |
| void GraphicsContext::addPath(const Path& path) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_path_t *p = cairo_copy_path(path.platformPath()->m_cr); |
| cairo_append_path(cr, p); |
| cairo_path_destroy(p); |
| } |
| |
| void GraphicsContext::clip(const Path& path) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_t* cr = m_data->cr; |
| cairo_path_t *p = cairo_copy_path(path.platformPath()->m_cr); |
| cairo_append_path(cr, p); |
| cairo_path_destroy(p); |
| cairo_clip(cr); |
| } |
| |
| void GraphicsContext::clipOut(const Path&) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::rotate(float radians) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_rotate(m_data->cr, radians); |
| } |
| |
| void GraphicsContext::scale(const FloatSize& size) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| cairo_scale(m_data->cr, size.width(), size.height()); |
| } |
| |
| void GraphicsContext::clipOut(const IntRect&) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::clipOutEllipseInRect(const IntRect&) |
| { |
| notImplemented(); |
| } |
| |
| void GraphicsContext::fillRoundedRect(const IntRect&, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color&) |
| { |
| notImplemented(); |
| } |
| |
| #if PLATFORM(GTK) |
| void GraphicsContext::setGdkExposeEvent(GdkEventExpose* expose) |
| { |
| m_data->expose = expose; |
| } |
| |
| GdkEventExpose* GraphicsContext::gdkExposeEvent() const |
| { |
| return m_data->expose; |
| } |
| |
| GdkDrawable* GraphicsContext::gdkDrawable() const |
| { |
| return GDK_DRAWABLE(m_data->expose->window); |
| } |
| |
| IntPoint GraphicsContext::translatePoint(const IntPoint& point) const |
| { |
| cairo_matrix_t tm; |
| cairo_get_matrix(m_data->cr, &tm); |
| double x = point.x(); |
| double y = point.y(); |
| |
| cairo_matrix_transform_point(&tm, &x, &y); |
| return IntPoint(x, y); |
| } |
| #endif |
| |
| } // namespace WebCore |
| |
| #endif // PLATFORM(CAIRO) |