GraphicsContextCG.cpp [plain text]
#define _USE_MATH_DEFINES 1
#include "config.h"
#include "GraphicsContext.h"
#if PLATFORM(CG)
#include "AffineTransform.h"
#include "KURL.h"
#include "Path.h"
#include <wtf/MathExtras.h>
#include <GraphicsContextPlatformPrivate.h> // FIXME: Temporary.
using namespace std;
namespace WebCore {
static void setCGFillColor(CGContextRef context, const Color& color)
{
CGFloat red, green, blue, alpha;
color.getRGBA(red, green, blue, alpha);
CGContextSetRGBFillColor(context, red, green, blue, alpha);
}
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);
}
GraphicsContext::GraphicsContext(CGContextRef cgContext)
: m_common(createGraphicsContextPrivate())
, m_data(new GraphicsContextPlatformPrivate(cgContext))
{
setPaintingDisabled(!cgContext);
if (cgContext) {
setPlatformFillColor(fillColor());
setPlatformStrokeColor(strokeColor());
}
}
GraphicsContext::~GraphicsContext()
{
destroyGraphicsContextPrivate(m_common);
delete m_data;
}
void GraphicsContext::setFocusRingClip(const IntRect& r)
{
m_data->m_focusRingClip = r;
}
void GraphicsContext::clearFocusRingClip()
{
m_data->m_focusRingClip = IntRect();
}
CGContextRef GraphicsContext::platformContext() const
{
ASSERT(!paintingDisabled());
ASSERT(m_data->m_cgContext);
return m_data->m_cgContext;
}
void GraphicsContext::savePlatformState()
{
CGContextSaveGState(platformContext());
m_data->save();
}
void GraphicsContext::restorePlatformState()
{
CGContextRestoreGState(platformContext());
m_data->restore();
}
void GraphicsContext::drawRect(const IntRect& rect)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
if (fillColor().alpha())
CGContextFillRect(context, rect);
if (strokeStyle() != NoStroke && strokeColor().alpha()) {
Color oldFillColor = fillColor();
if (oldFillColor != strokeColor())
setCGFillColor(context, strokeColor());
CGRect rects[4] = {
FloatRect(rect.x(), rect.y(), rect.width(), 1),
FloatRect(rect.x(), rect.bottom() - 1, rect.width(), 1),
FloatRect(rect.x(), rect.y() + 1, 1, rect.height() - 2),
FloatRect(rect.right() - 1, rect.y() + 1, 1, rect.height() - 2)
};
CGContextFillRects(context, rects, 4);
if (oldFillColor != strokeColor())
setCGFillColor(context, oldFillColor);
}
}
void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
{
if (paintingDisabled())
return;
if (strokeStyle() == NoStroke || !strokeColor().alpha())
return;
float width = strokeThickness();
FloatPoint p1 = point1;
FloatPoint p2 = point2;
bool isVerticalLine = (p1.x() == p2.x());
if (strokeStyle() == DottedStroke || strokeStyle() == DashedStroke) {
if (isVerticalLine) {
p1.move(0, width);
p2.move(0, -width);
} else {
p1.move(width, 0);
p2.move(-width, 0);
}
}
if (((int)width) % 2) {
if (isVerticalLine) {
p1.move(0.5f, 0.0f);
p2.move(0.5f, 0.0f);
} else {
p1.move(0.0f, 0.5f);
p2.move(0.0f, 0.5f);
}
}
int patWidth = 0;
switch (strokeStyle()) {
case NoStroke:
case SolidStroke:
break;
case DottedStroke:
patWidth = (int)width;
break;
case DashedStroke:
patWidth = 3 * (int)width;
break;
}
CGContextRef context = platformContext();
CGContextSaveGState(context);
CGContextSetShouldAntialias(context, false);
if (patWidth) {
setCGFillColor(context, strokeColor()); if (isVerticalLine) {
CGContextFillRect(context, FloatRect(p1.x() - width / 2, p1.y() - width, width, width));
CGContextFillRect(context, FloatRect(p2.x() - width / 2, p2.y(), width, width));
} else {
CGContextFillRect(context, FloatRect(p1.x() - width, p1.y() - width / 2, width, width));
CGContextFillRect(context, FloatRect(p2.x(), p2.y() - width / 2, width, width));
}
int distance = (isVerticalLine ? (point2.y() - point1.y()) : (point2.x() - point1.x())) - 2*(int)width;
int remainder = distance % patWidth;
int coverage = distance - remainder;
int numSegments = coverage / patWidth;
float patternOffset = 0.0f;
if (patWidth == 1)
patternOffset = 1.0f;
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 (remainder)
patternOffset = (patWidth - remainder)/2;
}
}
const CGFloat dottedLine[2] = { patWidth, patWidth };
CGContextSetLineDash(context, patternOffset, dottedLine, 2);
}
CGContextBeginPath(context);
CGContextMoveToPoint(context, p1.x(), p1.y());
CGContextAddLineToPoint(context, p2.x(), p2.y());
CGContextStrokePath(context);
CGContextRestoreGState(context);
}
void GraphicsContext::drawEllipse(const IntRect& rect)
{
ASSERT(rect.width() == rect.height());
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextBeginPath(context);
float r = (float)rect.width() / 2;
CGContextAddArc(context, rect.x() + r, rect.y() + r, r, 0.0f, 2.0f * piFloat, 0);
CGContextClosePath(context);
if (fillColor().alpha()) {
if (strokeStyle() != NoStroke)
CGContextDrawPath(context, kCGPathFillStroke);
else
CGContextFillPath(context);
} else if (strokeStyle() != NoStroke)
CGContextStrokePath(context);
}
void GraphicsContext::strokeArc(const IntRect& rect, int startAngle, int angleSpan)
{
if (paintingDisabled() || strokeStyle() == NoStroke || strokeThickness() <= 0.0f || !strokeColor().alpha())
return;
CGContextRef context = platformContext();
CGContextSaveGState(context);
CGContextBeginPath(context);
CGContextSetShouldAntialias(context, false);
int x = rect.x();
int y = rect.y();
float w = (float)rect.width();
float h = (float)rect.height();
float scaleFactor = h / w;
float reverseScaleFactor = w / h;
if (w != h)
scale(FloatSize(1, scaleFactor));
float hRadius = w / 2;
float vRadius = h / 2;
float fa = startAngle;
float falen = fa + angleSpan;
float start = -fa * piFloat / 180.0f;
float end = -falen * piFloat / 180.0f;
CGContextAddArc(context, x + hRadius, (y + vRadius) * reverseScaleFactor, hRadius, start, end, true);
if (w != h)
scale(FloatSize(1, reverseScaleFactor));
float width = strokeThickness();
int patWidth = 0;
switch (strokeStyle()) {
case DottedStroke:
patWidth = (int)(width / 2);
break;
case DashedStroke:
patWidth = 3 * (int)(width / 2);
break;
default:
break;
}
CGContextSaveGState(context);
if (patWidth) {
int distance;
if (hRadius == vRadius)
distance = static_cast<int>((piFloat * hRadius) / 2.0f);
else distance = static_cast<int>((piFloat * sqrtf((hRadius * hRadius + vRadius * vRadius) / 2.0f)) / 2.0f);
int remainder = distance % patWidth;
int coverage = distance - remainder;
int numSegments = coverage / patWidth;
float patternOffset = 0.0f;
if (patWidth == 1)
patternOffset = 1.0f;
else {
bool evenNumberOfSegments = numSegments % 2 == 0;
if (remainder)
evenNumberOfSegments = !evenNumberOfSegments;
if (evenNumberOfSegments) {
if (remainder) {
patternOffset += patWidth - remainder;
patternOffset += remainder / 2.0f;
} else
patternOffset = patWidth / 2.0f;
} else {
if (remainder)
patternOffset = (patWidth - remainder) / 2.0f;
}
}
const CGFloat dottedLine[2] = { patWidth, patWidth };
CGContextSetLineDash(context, patternOffset, dottedLine, 2);
}
CGContextStrokePath(context);
CGContextRestoreGState(context);
CGContextRestoreGState(context);
}
void GraphicsContext::drawConvexPolygon(size_t npoints, const FloatPoint* points, bool shouldAntialias)
{
if (paintingDisabled() || !fillColor().alpha() && (strokeThickness() <= 0 || strokeStyle() == NoStroke))
return;
if (npoints <= 1)
return;
CGContextRef context = platformContext();
CGContextSaveGState(context);
CGContextSetShouldAntialias(context, shouldAntialias);
CGContextBeginPath(context);
CGContextMoveToPoint(context, points[0].x(), points[0].y());
for (size_t i = 1; i < npoints; i++)
CGContextAddLineToPoint(context, points[i].x(), points[i].y());
CGContextClosePath(context);
if (fillColor().alpha()) {
if (strokeStyle() != NoStroke)
CGContextDrawPath(context, kCGPathEOFillStroke);
else
CGContextEOFillPath(context);
} else
CGContextStrokePath(context);
CGContextRestoreGState(context);
}
void GraphicsContext::fillRect(const IntRect& rect, const Color& color)
{
if (paintingDisabled())
return;
if (color.alpha()) {
CGContextRef context = platformContext();
Color oldFillColor = fillColor();
if (oldFillColor != color)
setCGFillColor(context, color);
CGContextFillRect(context, rect);
if (oldFillColor != color)
setCGFillColor(context, oldFillColor);
}
}
void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
{
if (paintingDisabled())
return;
if (color.alpha()) {
CGContextRef context = platformContext();
Color oldFillColor = fillColor();
if (oldFillColor != color)
setCGFillColor(context, color);
CGContextFillRect(context, rect);
if (oldFillColor != color)
setCGFillColor(context, oldFillColor);
}
}
void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color)
{
if (paintingDisabled() || !color.alpha())
return;
CGContextRef context = platformContext();
Color oldFillColor = fillColor();
if (oldFillColor != color)
setCGFillColor(context, color);
addPath(Path::createRoundedRectangle(rect, topLeft, topRight, bottomLeft, bottomRight));
CGContextFillPath(context);
if (oldFillColor != color)
setCGFillColor(context, oldFillColor);
}
void GraphicsContext::clip(const IntRect& rect)
{
if (paintingDisabled())
return;
CGContextClipToRect(platformContext(), rect);
m_data->clip(rect);
}
void GraphicsContext::clipOut(const IntRect& rect)
{
if (paintingDisabled())
return;
CGRect rects[2] = { CGContextGetClipBoundingBox(platformContext()), rect };
CGContextBeginPath(platformContext());
CGContextAddRects(platformContext(), rects, 2);
CGContextEOClip(platformContext());
}
void GraphicsContext::clipOutEllipseInRect(const IntRect& rect)
{
if (paintingDisabled())
return;
CGContextBeginPath(platformContext());
CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
CGContextAddEllipseInRect(platformContext(), rect);
CGContextEOClip(platformContext());
}
void GraphicsContext::addInnerRoundedRectClip(const IntRect& rect, int thickness)
{
if (paintingDisabled())
return;
clip(rect);
CGContextRef context = platformContext();
CGContextAddEllipseInRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
CGContextAddEllipseInRect(context, CGRectMake(rect.x() + thickness, rect.y() + thickness,
rect.width() - (thickness * 2), rect.height() - (thickness * 2)));
CGContextEOClip(context);
}
void GraphicsContext::beginTransparencyLayer(float opacity)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextSaveGState(context);
CGContextSetAlpha(context, opacity);
CGContextBeginTransparencyLayer(context, 0);
m_data->beginTransparencyLayer();
}
void GraphicsContext::endTransparencyLayer()
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextEndTransparencyLayer(context);
CGContextRestoreGState(context);
m_data->endTransparencyLayer();
}
void GraphicsContext::setShadow(const IntSize& size, int blur, const Color& color)
{
blur = min(blur, 1000);
if (paintingDisabled())
return;
CGContextRef context = platformContext();
if (!color.isValid())
CGContextSetShadow(context, CGSizeMake(size.width(), -size.height()), blur); else {
CGColorRef colorCG = cgColor(color);
CGContextSetShadowWithColor(context,
CGSizeMake(size.width(), -size.height()), blur,
colorCG);
CGColorRelease(colorCG);
}
}
void GraphicsContext::clearShadow()
{
if (paintingDisabled())
return;
CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
}
void GraphicsContext::setMiterLimit(float limit)
{
if (paintingDisabled())
return;
CGContextSetMiterLimit(platformContext(), limit);
}
void GraphicsContext::setAlpha(float alpha)
{
if (paintingDisabled())
return;
CGContextSetAlpha(platformContext(), alpha);
}
void GraphicsContext::clearRect(const FloatRect& r)
{
if (paintingDisabled())
return;
CGContextClearRect(platformContext(), r);
}
void GraphicsContext::strokeRect(const FloatRect& r, float lineWidth)
{
if (paintingDisabled())
return;
CGContextStrokeRectWithWidth(platformContext(), r, lineWidth);
}
void GraphicsContext::setLineCap(LineCap cap)
{
if (paintingDisabled())
return;
switch (cap) {
case ButtCap:
CGContextSetLineCap(platformContext(), kCGLineCapButt);
break;
case RoundCap:
CGContextSetLineCap(platformContext(), kCGLineCapRound);
break;
case SquareCap:
CGContextSetLineCap(platformContext(), kCGLineCapSquare);
break;
}
}
void GraphicsContext::setLineJoin(LineJoin join)
{
if (paintingDisabled())
return;
switch (join) {
case MiterJoin:
CGContextSetLineJoin(platformContext(), kCGLineJoinMiter);
break;
case RoundJoin:
CGContextSetLineJoin(platformContext(), kCGLineJoinRound);
break;
case BevelJoin:
CGContextSetLineJoin(platformContext(), kCGLineJoinBevel);
break;
}
}
void GraphicsContext::beginPath()
{
CGContextBeginPath(platformContext());
}
void GraphicsContext::addPath(const Path& path)
{
CGContextAddPath(platformContext(), path.platformPath());
}
void GraphicsContext::clip(const Path& path)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
CGContextBeginPath(context);
CGContextAddPath(context, path.platformPath());
CGContextClip(context);
m_data->clip(path);
}
void GraphicsContext::clipOut(const Path& path)
{
if (paintingDisabled())
return;
CGContextBeginPath(platformContext());
CGContextAddRect(platformContext(), CGContextGetClipBoundingBox(platformContext()));
CGContextAddPath(platformContext(), path.platformPath());
CGContextEOClip(platformContext());
}
void GraphicsContext::scale(const FloatSize& size)
{
if (paintingDisabled())
return;
CGContextScaleCTM(platformContext(), size.width(), size.height());
m_data->scale(size);
}
void GraphicsContext::rotate(float angle)
{
if (paintingDisabled())
return;
CGContextRotateCTM(platformContext(), angle);
m_data->rotate(angle);
}
void GraphicsContext::translate(float x, float y)
{
if (paintingDisabled())
return;
CGContextTranslateCTM(platformContext(), x, y);
m_data->translate(x, y);
}
void GraphicsContext::concatCTM(const AffineTransform& transform)
{
if (paintingDisabled())
return;
CGContextConcatCTM(platformContext(), transform);
m_data->concatCTM(transform);
}
FloatRect GraphicsContext::roundToDevicePixels(const FloatRect& rect)
{
CGAffineTransform deviceMatrix = CGContextGetUserSpaceToDeviceSpaceTransform(platformContext());
if (CGAffineTransformIsIdentity(deviceMatrix))
return rect;
float deviceScaleX = sqrtf(deviceMatrix.a * deviceMatrix.a + deviceMatrix.b * deviceMatrix.b);
float deviceScaleY = sqrtf(deviceMatrix.c * deviceMatrix.c + deviceMatrix.d * deviceMatrix.d);
CGPoint deviceOrigin = CGPointMake(rect.x() * deviceScaleX, rect.y() * deviceScaleY);
CGPoint deviceLowerRight = CGPointMake((rect.x() + rect.width()) * deviceScaleX,
(rect.y() + rect.height()) * deviceScaleY);
deviceOrigin.x = roundf(deviceOrigin.x);
deviceOrigin.y = roundf(deviceOrigin.y);
deviceLowerRight.x = roundf(deviceLowerRight.x);
deviceLowerRight.y = roundf(deviceLowerRight.y);
if (deviceOrigin.y == deviceLowerRight.y && rect.height() != 0)
deviceLowerRight.y += 1;
if (deviceOrigin.x == deviceLowerRight.x && rect.width() != 0)
deviceLowerRight.x += 1;
FloatPoint roundedOrigin = FloatPoint(deviceOrigin.x / deviceScaleX, deviceOrigin.y / deviceScaleY);
FloatPoint roundedLowerRight = FloatPoint(deviceLowerRight.x / deviceScaleX, deviceLowerRight.y / deviceScaleY);
return FloatRect(roundedOrigin, roundedLowerRight - roundedOrigin);
}
void GraphicsContext::drawLineForText(const IntPoint& point, int width, bool printing)
{
if (paintingDisabled())
return;
if (width <= 0)
return;
CGContextSaveGState(platformContext());
float x = point.x();
float y = point.y();
float lineLength = width;
float thickness = max(strokeThickness(), 0.5f);
if (!printing) {
float adjustedThickness = max(thickness, 1.0f);
CGRect lineRect = roundToDevicePixels(FloatRect(x, y, lineLength, adjustedThickness));
if (lineRect.size.height < thickness * 2.0) {
x = lineRect.origin.x;
y = lineRect.origin.y;
lineLength = lineRect.size.width;
thickness = lineRect.size.height;
CGContextSetShouldAntialias(platformContext(), false);
}
}
if (fillColor() != strokeColor())
setCGFillColor(platformContext(), strokeColor());
CGContextFillRect(platformContext(), CGRectMake(x, y, lineLength, thickness));
CGContextRestoreGState(platformContext());
}
void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
{
if (paintingDisabled())
return;
CFURLRef urlRef = link.createCFURL();
if (urlRef) {
CGContextRef context = platformContext();
CGRect box = CGContextGetClipBoundingBox(context);
IntRect intBox((int)box.origin.x, (int)box.origin.y, (int)box.size.width, (int)box.size.height);
IntRect rect = destRect;
rect.intersect(intBox);
CGPDFContextSetURLForRect(context, urlRef,
CGRectApplyAffineTransform(rect, CGContextGetCTM(context)));
CFRelease(urlRef);
}
}
void GraphicsContext::setUseLowQualityImageInterpolation(bool lowQualityMode)
{
if (paintingDisabled())
return;
CGContextSetInterpolationQuality(platformContext(), lowQualityMode ? kCGInterpolationNone : kCGInterpolationDefault);
}
bool GraphicsContext::useLowQualityImageInterpolation() const
{
if (paintingDisabled())
return false;
return CGContextGetInterpolationQuality(platformContext());
}
void GraphicsContext::setPlatformTextDrawingMode(int mode)
{
if (paintingDisabled())
return;
CGContextRef context = platformContext();
switch (mode) {
case cTextInvisible: CGContextSetTextDrawingMode(context, kCGTextInvisible);
break;
case cTextFill: CGContextSetTextDrawingMode(context, kCGTextFill);
break;
case cTextStroke: CGContextSetTextDrawingMode(context, kCGTextStroke);
break;
case 3: CGContextSetTextDrawingMode(context, kCGTextFillStroke);
break;
case cTextClip: CGContextSetTextDrawingMode(context, kCGTextClip);
break;
case 5: CGContextSetTextDrawingMode(context, kCGTextFillClip);
break;
case 6: CGContextSetTextDrawingMode(context, kCGTextStrokeClip);
break;
case 7: CGContextSetTextDrawingMode(context, kCGTextFillStrokeClip);
break;
default:
break;
}
}
void GraphicsContext::setPlatformStrokeColor(const Color& color)
{
if (paintingDisabled())
return;
setCGStrokeColor(platformContext(), color);
}
void GraphicsContext::setPlatformStrokeThickness(float thickness)
{
if (paintingDisabled())
return;
CGContextSetLineWidth(platformContext(), thickness);
}
void GraphicsContext::setPlatformFillColor(const Color& color)
{
if (paintingDisabled())
return;
setCGFillColor(platformContext(), color);
}
}
#endif // PLATFORM(CG)