| /* |
| * Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved. |
| * |
| * 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" |
| |
| #include "AffineTransform.h" |
| #include "NotImplemented.h" |
| #include "Path.h" |
| #include <WebKitSystemInterface/WebKitSystemInterface.h> |
| #include <wtf/MathExtras.h> |
| |
| #include "GraphicsContextPlatformPrivate.h" |
| #include "WebCoreSystemInterface.h" |
| |
| using namespace std; |
| |
| namespace WebCore { |
| |
| class SVGResourceImage; |
| |
| static CGContextRef CGContextWithHDC(HDC hdc) |
| { |
| HBITMAP bitmap = (HBITMAP)GetCurrentObject(hdc, OBJ_BITMAP); |
| CGColorSpaceRef deviceRGB = CGColorSpaceCreateDeviceRGB(); |
| BITMAP info; |
| |
| GetObject(bitmap, sizeof(info), &info); |
| ASSERT(info.bmBitsPixel == 32); |
| CGContextRef context = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8, |
| info.bmWidthBytes, deviceRGB, kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst); |
| CGColorSpaceRelease(deviceRGB); |
| |
| // Flip coords |
| CGContextTranslateCTM(context, 0, info.bmHeight); |
| CGContextScaleCTM(context, 1, -1); |
| |
| // Put the HDC In advanced mode so it will honor affine transforms. |
| SetGraphicsMode(hdc, GM_ADVANCED); |
| |
| return context; |
| } |
| |
| GraphicsContext::GraphicsContext(HDC hdc) |
| : m_common(createGraphicsContextPrivate()) |
| , m_data(new GraphicsContextPlatformPrivate(CGContextWithHDC(hdc))) |
| { |
| CGContextRelease(m_data->m_cgContext); |
| m_data->m_hdc = hdc; |
| setPaintingDisabled(!m_data->m_cgContext); |
| if (m_data->m_cgContext) { |
| // Make sure the context starts in sync with our state. |
| setPlatformFillColor(fillColor()); |
| setPlatformStrokeColor(strokeColor()); |
| } |
| } |
| |
| HDC GraphicsContext::getWindowsContext(bool supportAlphaBlend, const IntRect* dstRect) |
| { |
| if (m_data->m_transparencyCount) { |
| // We're in a transparency layer. |
| ASSERT(dstRect); |
| if (!dstRect) |
| return 0; |
| |
| // Create a bitmap DC in which to draw. |
| BITMAPINFO bitmapInfo; |
| bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); |
| bitmapInfo.bmiHeader.biWidth = dstRect->width(); |
| bitmapInfo.bmiHeader.biHeight = dstRect->height(); |
| bitmapInfo.bmiHeader.biPlanes = 1; |
| bitmapInfo.bmiHeader.biBitCount = 32; |
| bitmapInfo.bmiHeader.biCompression = BI_RGB; |
| bitmapInfo.bmiHeader.biSizeImage = 0; |
| bitmapInfo.bmiHeader.biXPelsPerMeter = 0; |
| bitmapInfo.bmiHeader.biYPelsPerMeter = 0; |
| bitmapInfo.bmiHeader.biClrUsed = 0; |
| bitmapInfo.bmiHeader.biClrImportant = 0; |
| |
| void* pixels = 0; |
| HBITMAP bitmap = ::CreateDIBSection(NULL, &bitmapInfo, DIB_RGB_COLORS, &pixels, 0, 0); |
| if (!bitmap) |
| return 0; |
| |
| HDC bitmapDC = ::CreateCompatibleDC(m_data->m_hdc); |
| ::SelectObject(bitmapDC, bitmap); |
| |
| // Fill our buffer with clear if we're going to alpha blend. |
| if (supportAlphaBlend) { |
| BITMAP bmpInfo; |
| GetObject(bitmap, sizeof(bmpInfo), &bmpInfo); |
| int bufferSize = bmpInfo.bmWidthBytes * bmpInfo.bmHeight; |
| memset(bmpInfo.bmBits, 0, bufferSize); |
| } |
| |
| // Make sure we can do world transforms. |
| SetGraphicsMode(bitmapDC, GM_ADVANCED); |
| |
| // Apply a translation to our context so that the drawing done will be at (0,0) of the bitmap. |
| XFORM xform; |
| xform.eM11 = 1.0; |
| xform.eM12 = 0; |
| xform.eM21 = 0; |
| xform.eM22 = 1.0; |
| xform.eDx = -dstRect->x(); |
| xform.eDy = -dstRect->y(); |
| ::SetWorldTransform(bitmapDC, &xform); |
| |
| return bitmapDC; |
| } |
| |
| CGContextFlush(platformContext()); |
| m_data->save(); |
| return m_data->m_hdc; |
| } |
| |
| void GraphicsContext::releaseWindowsContext(HDC hdc, bool supportAlphaBlend, const IntRect* dstRect) |
| { |
| if (hdc && m_data->m_transparencyCount) { |
| HBITMAP bitmap = (HBITMAP)GetCurrentObject(hdc, OBJ_BITMAP); |
| |
| // Need to make a CGImage out of the bitmap's pixel buffer and then draw |
| // it into our context. |
| BITMAP info; |
| GetObject(bitmap, sizeof(info), &info); |
| ASSERT(info.bmBitsPixel == 32); |
| |
| CGColorSpaceRef deviceRGB = CGColorSpaceCreateDeviceRGB(); |
| CGContextRef bitmapContext = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8, |
| info.bmWidthBytes, deviceRGB, kCGBitmapByteOrder32Little | |
| (supportAlphaBlend ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst)); |
| CGColorSpaceRelease(deviceRGB); |
| |
| CGImageRef image = CGBitmapContextCreateImage(bitmapContext); |
| CGContextDrawImage(m_data->m_cgContext, *dstRect, image); |
| |
| // Delete all our junk. |
| CGImageRelease(image); |
| CGContextRelease(bitmapContext); |
| ::DeleteDC(hdc); |
| ::DeleteObject(bitmap); |
| |
| return; |
| } |
| |
| m_data->restore(); |
| } |
| |
| void GraphicsContextPlatformPrivate::save() |
| { |
| if (!m_hdc) |
| return; |
| SaveDC(m_hdc); |
| } |
| |
| void GraphicsContextPlatformPrivate::restore() |
| { |
| if (!m_hdc) |
| return; |
| RestoreDC(m_hdc, -1); |
| } |
| |
| void GraphicsContextPlatformPrivate::clip(const IntRect& clipRect) |
| { |
| if (!m_hdc) |
| return; |
| IntersectClipRect(m_hdc, clipRect.x(), clipRect.y(), clipRect.right(), clipRect.bottom()); |
| } |
| |
| void GraphicsContextPlatformPrivate::scale(const FloatSize& size) |
| { |
| if (!m_hdc) |
| return; |
| XFORM xform; |
| xform.eM11 = size.width(); |
| xform.eM12 = 0; |
| xform.eM21 = 0; |
| xform.eM22 = size.height(); |
| xform.eDx = 0; |
| xform.eDy = 0; |
| ModifyWorldTransform(m_hdc, &xform, MWT_LEFTMULTIPLY); |
| } |
| |
| static const double deg2rad = 0.017453292519943295769; // pi/180 |
| |
| void GraphicsContextPlatformPrivate::rotate(float degreesAngle) |
| { |
| float radiansAngle = degreesAngle * deg2rad; |
| float cosAngle = cosf(radiansAngle); |
| float sinAngle = sinf(radiansAngle); |
| XFORM xform; |
| xform.eM11 = cosAngle; |
| xform.eM12 = -sinAngle; |
| xform.eM21 = sinAngle; |
| xform.eM22 = cosAngle; |
| xform.eDx = 0; |
| xform.eDy = 0; |
| ModifyWorldTransform(m_hdc, &xform, MWT_LEFTMULTIPLY); |
| } |
| |
| void GraphicsContextPlatformPrivate::translate(float x , float y) |
| { |
| if (!m_hdc) |
| return; |
| XFORM xform; |
| xform.eM11 = 1.0; |
| xform.eM12 = 0; |
| xform.eM21 = 0; |
| xform.eM22 = 1.0; |
| xform.eDx = x; |
| xform.eDy = y; |
| ModifyWorldTransform(m_hdc, &xform, MWT_LEFTMULTIPLY); |
| } |
| |
| void GraphicsContextPlatformPrivate::concatCTM(const AffineTransform& transform) |
| { |
| if (!m_hdc) |
| return; |
| CGAffineTransform mat = transform; |
| XFORM xform; |
| xform.eM11 = mat.a; |
| xform.eM12 = mat.b; |
| xform.eM21 = mat.c; |
| xform.eM22 = mat.d; |
| xform.eDx = mat.tx; |
| xform.eDy = mat.ty; |
| ModifyWorldTransform(m_hdc, &xform, MWT_LEFTMULTIPLY); |
| } |
| |
| void GraphicsContext::setCompositeOperation(CompositeOperator mode) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| CGBlendMode target = kCGBlendModeNormal; |
| switch (mode) { |
| case CompositeClear: |
| target = kCGBlendModeClear; |
| break; |
| case CompositeCopy: |
| target = kCGBlendModeCopy; |
| break; |
| case CompositeSourceOver: |
| //kCGBlendModeNormal |
| break; |
| case CompositeSourceIn: |
| target = kCGBlendModeSourceIn; |
| break; |
| case CompositeSourceOut: |
| target = kCGBlendModeSourceOut; |
| break; |
| case CompositeSourceAtop: |
| target = kCGBlendModeSourceAtop; |
| break; |
| case CompositeDestinationOver: |
| target = kCGBlendModeDestinationOver; |
| break; |
| case CompositeDestinationIn: |
| target = kCGBlendModeDestinationIn; |
| break; |
| case CompositeDestinationOut: |
| target = kCGBlendModeDestinationOut; |
| break; |
| case CompositeDestinationAtop: |
| target = kCGBlendModeDestinationAtop; |
| break; |
| case CompositeXOR: |
| target = kCGBlendModeXOR; |
| break; |
| case CompositePlusDarker: |
| target = kCGBlendModePlusDarker; |
| break; |
| case CompositeHighlight: |
| // currently unsupported |
| break; |
| case CompositePlusLighter: |
| target = kCGBlendModePlusLighter; |
| break; |
| } |
| CGContextSetBlendMode(platformContext(), target); |
| } |
| |
| void GraphicsContext::drawFocusRing(const Color& color) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| float radius = (focusRingWidth() - 1) / 2.0f; |
| int offset = radius + focusRingOffset(); |
| CGColorRef colorRef = color.isValid() ? cgColor(color) : 0; |
| |
| CGMutablePathRef focusRingPath = CGPathCreateMutable(); |
| const Vector<IntRect>& rects = focusRingRects(); |
| unsigned rectCount = rects.size(); |
| for (unsigned i = 0; i < rectCount; i++) |
| CGPathAddRect(focusRingPath, 0, CGRectInset(rects[i], -offset, -offset)); |
| |
| CGContextRef context = platformContext(); |
| CGContextSaveGState(context); |
| |
| CGContextBeginPath(context); |
| CGContextAddPath(context, focusRingPath); |
| |
| wkDrawFocusRing(context, colorRef, radius); |
| |
| CGColorRelease(colorRef); |
| |
| CGPathRelease(focusRingPath); |
| |
| CGContextRestoreGState(context); |
| } |
| |
| static const Color& spellingPatternColor() { |
| static const Color spellingColor(255, 0, 0); |
| return spellingColor; |
| } |
| |
| static const Color& grammarPatternColor() { |
| static const Color grammarColor(0, 128, 0); |
| return grammarColor; |
| } |
| |
| // Pulled from GraphicsContextCG |
| static void setCGStrokeColor(CGContextRef context, const Color& color) |
| { |
| CGFloat red, green, blue, alpha; |
| color.getRGBA(red, green, blue, alpha); |
| CGContextSetRGBStrokeColor(context, red, green, blue, alpha); |
| } |
| |
| void GraphicsContext::drawLineForMisspellingOrBadGrammar(const IntPoint& point, int width, bool grammar) |
| { |
| if (paintingDisabled()) |
| return; |
| |
| // These are the same for misspelling or bad grammar |
| const int patternHeight = 3; // 3 rows |
| ASSERT(cMisspellingLineThickness == patternHeight); |
| const int patternWidth = 4; // 4 pixels |
| ASSERT(patternWidth == cMisspellingLinePatternWidth); |
| |
| // Make sure to draw only complete dots. |
| // NOTE: Code here used to shift the underline to the left and increase the width |
| // to make sure everything gets underlined, but that results in drawing out of |
| // bounds (e.g. when at the edge of a view) and could make it appear that the |
| // space between adjacent misspelled words was underlined. |
| // allow slightly more considering that the pattern ends with a transparent pixel |
| int widthMod = width % patternWidth; |
| if (patternWidth - widthMod > cMisspellingLinePatternGapWidth) |
| width -= widthMod; |
| |
| // Draw the underline |
| CGContextRef context = platformContext(); |
| CGContextSaveGState(context); |
| |
| const Color& patternColor = grammar ? grammarPatternColor() : spellingPatternColor(); |
| setCGStrokeColor(context, patternColor); |
| |
| wkSetPatternPhaseInUserSpace(context, point); |
| CGContextSetBlendMode(context, kCGBlendModeNormal); |
| |
| // 3 rows, each offset by half a pixel for blending purposes |
| const CGPoint upperPoints [] = {{point.x(), point.y() + patternHeight - 2.5 }, {point.x() + width, point.y() + patternHeight - 2.5}}; |
| const CGPoint middlePoints [] = {{point.x(), point.y() + patternHeight - 1.5 }, {point.x() + width, point.y() + patternHeight - 1.5}}; |
| const CGPoint lowerPoints [] = {{point.x(), point.y() + patternHeight - 0.5 }, {point.x() + width, point.y() + patternHeight - 0.5 }}; |
| |
| // Dash lengths for the top and bottom of the error underline are the same. |
| // These are magic. |
| static const float edge_dash_lengths[] = {2, 2}; |
| static const float middle_dash_lengths[] = {2.76f, 1.24f}; |
| static const float edge_offset = -(edge_dash_lengths[1] - 1.0f) / 2.0f; |
| static const float middle_offset = -(middle_dash_lengths[1] - 1.0f) / 2.0f; |
| |
| // Line opacities. Once again, these are magic. |
| const float upperOpacity = 0.33f; |
| const float middleOpacity = 0.75f; |
| const float lowerOpacity = 0.88f; |
| |
| //Top line |
| CGContextSetLineDash(context, edge_offset, edge_dash_lengths, |
| sizeof(edge_dash_lengths) / sizeof(edge_dash_lengths[0])); |
| CGContextSetAlpha(context, upperOpacity); |
| CGContextStrokeLineSegments(context, upperPoints, 2); |
| |
| // Middle line |
| CGContextSetLineDash(context, middle_offset, middle_dash_lengths, |
| sizeof(middle_dash_lengths) / sizeof(middle_dash_lengths[0])); |
| CGContextSetAlpha(context, middleOpacity); |
| CGContextStrokeLineSegments(context, middlePoints, 2); |
| |
| // Bottom line |
| CGContextSetLineDash(context, edge_offset, edge_dash_lengths, |
| sizeof(edge_dash_lengths) / sizeof(edge_dash_lengths[0])); |
| CGContextSetAlpha(context, lowerOpacity); |
| CGContextStrokeLineSegments(context, lowerPoints, 2); |
| |
| CGContextRestoreGState(context); |
| } |
| |
| #if ENABLE(SVG) |
| GraphicsContext* contextForImage(SVGResourceImage*) |
| { |
| // FIXME: This should go in GraphicsContextCG.cpp |
| notImplemented(); |
| return 0; |
| } |
| #endif |
| |
| } |
