void SVGPaintServerGradient::teardown(GraphicsContext*& context, const RenderObject* object, SVGPaintTargetType type, bool isPaintingText) const
{
CGShadingRef shading = m_shadingCache;
CGContextRef contextRef = context->platformContext();
RenderStyle* style = object->style();
ASSERT(contextRef);
// As renderPath() is not used when painting text, special logic needed here.
if (isPaintingText) {
IntRect textBoundary = const_cast<RenderObject*>(object)->absoluteBoundingBoxRect();
FloatRect targetRect = object->absoluteTransform().inverse().mapRect(textBoundary);
handleBoundingBoxModeAndGradientTransformation(context, targetRect);
}
if ((type & ApplyToFillTargetType) && style->svgStyle()->hasFill()) {
// workaround for filling the entire screen with the shading in the case that no text was intersected with the clip
if (!isPaintingText || (object->width() > 0 && object->height() > 0))
CGContextDrawShading(contextRef, shading);
context->restore();
}
if ((type & ApplyToStrokeTargetType) && style->svgStyle()->hasStroke()) {
if (isPaintingText && m_savedContext) {
IntRect maskRect = const_cast<RenderObject*>(object)->absoluteBoundingBoxRect();
maskRect = object->absoluteTransform().inverse().mapRect(maskRect);
// Translate from 0x0 image origin to actual rendering position
m_savedContext->translate(maskRect.x(), maskRect.y());
// Clip current context to mask image (gradient)
CGContextClipToMask(m_savedContext->platformContext(), CGRectMake(0, 0, maskRect.width(), maskRect.height()), m_imageBuffer->cgImage());
m_savedContext->translate(-maskRect.x(), -maskRect.y());
// Restore on-screen drawing context, after we got the image of the gradient
delete m_imageBuffer;
context = m_savedContext;
contextRef = context->platformContext();
m_savedContext = 0;
m_imageBuffer = 0;
}
CGContextDrawShading(contextRef, shading);
context->restore();
}
context->restore();
}
// -----------------------------------------------------------------------------
// ShadeRectColor
// -----------------------------------------------------------------------------
//
OSStatus ShadeRectColor(
const CGRGB* inStartColor,
const CGRGB* inEndColor,
const HIRect* inRect,
CGContextRef inContext )
{
OSStatus err = noErr;
CGColorSpaceRef colorSpace;
CGFunctionCallbacks callbacks = { 0, ColorGradientEvaluate, NULL };
CGFunctionRef function;
CGShadingRef shading;
ColorShadeData data;
// Warning: this stuff is sitting on the stack. Be careful if you move
// the shading code around.
data.start = *inStartColor;
data.range.red = inEndColor->red - inStartColor->red;
data.range.green = inEndColor->green - inStartColor->green;
data.range.blue = inEndColor->blue - inStartColor->blue;
CGContextSaveGState( inContext );
CGContextClipToRect( inContext, *inRect );
colorSpace = CGColorSpaceCreateDeviceRGB();
require_action( colorSpace != NULL, CantCreateColorSpace, err = memFullErr );
function = CGFunctionCreate(
&data, // info
1, // domainDimension
NULL, // input domain NULL == no range clipping
4, // rangeDimension,
NULL, // output domain NULL == no range clipping
&callbacks ); // CGFunctionCallbacks
require_action( function != NULL, CantCreateFunction, err = memFullErr );
shading = CGShadingCreateAxial(
colorSpace,
inRect->origin, // start
CGPointMake( CGRectGetMinX( *inRect ), CGRectGetMaxY( *inRect ) ), // end
function,
false, // extendStart
false ); // extendEnd
require_action( colorSpace != NULL, CantCreateShading, err = memFullErr );
CGContextDrawShading( inContext, shading);
CantCreateFunction:
CGShadingRelease( shading );
CantCreateShading:
CGColorSpaceRelease( colorSpace );
CantCreateColorSpace:
CGContextRestoreGState( inContext );
return err;
}
void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height, ExceptionCode& ec)
{
ec = 0;
if (!(width >= 0 && height >= 0)) {
ec = INDEX_SIZE_ERR;
return;
}
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
CGRect rect = CGRectMake(x, y, width, height);
willDraw(rect);
if (state().m_fillStyle->gradient()) {
// Shading works on the entire clip region, so convert the rect to a clip.
c->save();
CGContextClipToRect(c->platformContext(), rect);
CGContextDrawShading(c->platformContext(), state().m_fillStyle->gradient()->platformShading());
c->restore();
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
CGContextFillRect(c->platformContext(), rect);
}
#elif PLATFORM(QT)
QRectF rect(x, y, width, height);
willDraw(rect);
QPainter* p = static_cast<QPainter*>(c->platformContext());
if (state().m_fillStyle->gradient()) {
p->fillRect(rect, QBrush(*(state().m_fillStyle->gradient()->platformShading())));
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
p->fillRect(rect, p->brush());
}
#elif PLATFORM(CAIRO)
FloatRect rect(x, y, width, height);
willDraw(rect);
cairo_t* cr = c->platformContext();
cairo_save(cr);
if (state().m_fillStyle->gradient()) {
cairo_set_source(cr, state().m_fillStyle->gradient()->platformShading());
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
}
cairo_rectangle(cr, x, y, width, height);
cairo_fill(cr);
cairo_restore(cr);
#endif
}
void CanvasRenderingContext2D::fill()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
CGContextBeginPath(c->platformContext());
CGContextAddPath(c->platformContext(), state().m_path.platformPath());
if (!state().m_path.isEmpty())
willDraw(CGContextGetPathBoundingBox(c->platformContext()));
if (state().m_fillStyle->gradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_fillStyle->gradient()->platformShading());
c->restore();
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
CGContextFillPath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = state().m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
willDraw(path->controlPointRect());
if (state().m_fillStyle->gradient()) {
p->fillPath(*path, QBrush(*(state().m_fillStyle->gradient()->platformShading())));
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
p->fillPath(*path, p->brush());
}
#elif PLATFORM(CAIRO)
cairo_t* pathCr = state().m_path.platformPath()->m_cr;
cairo_t* cr = c->platformContext();
cairo_save(cr);
willDraw(state().m_path.boundingRect());
if (state().m_fillStyle->gradient()) {
cairo_set_source(cr, state().m_fillStyle->gradient()->platformShading());
c->addPath(state().m_path);
cairo_fill(cr);
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
c->addPath(state().m_path);
cairo_fill(cr);
}
cairo_restore(cr);
#endif
clearPathForDashboardBackwardCompatibilityMode();
}
void CanvasRenderingContext2D::fill()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
c->beginPath();
c->addPath(m_path);
if (!m_path.isEmpty())
willDraw(m_path.boundingRect());
#if PLATFORM(CG)
if (state().m_fillStyle->canvasGradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_fillStyle->canvasGradient()->gradient().platformGradient());
c->restore();
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
CGContextFillPath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
if (state().m_fillStyle->canvasGradient()) {
p->fillPath(*path, QBrush(*(state().m_fillStyle->canvasGradient()->gradient().platformGradient())));
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
p->fillPath(*path, p->brush());
}
#elif PLATFORM(CAIRO) && !PLATFORM(BAL)
cairo_t* cr = c->platformContext();
cairo_save(cr);
if (state().m_fillStyle->canvasGradient()) {
cairo_set_source(cr, state().m_fillStyle->canvasGradient()->gradient().platformGradient());
cairo_fill(cr);
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
cairo_fill(cr);
}
cairo_restore(cr);
#elif PLATFORM(BAL)
//FIXME
notImplemented();
#endif
#if ENABLE(DASHBOARD_SUPPORT)
clearPathForDashboardBackwardCompatibilityMode();
#endif
}
void Gradient::paint(GraphicsContext* context)
{
#ifdef BUILDING_ON_TIGER
CGContextDrawShading(context->platformContext(), platformGradient());
#else
CGGradientDrawingOptions extendOptions = kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation;
if (m_radial)
CGContextDrawRadialGradient(context->platformContext(), platformGradient(), m_p0, m_r0, m_p1, m_r1, extendOptions);
else
CGContextDrawLinearGradient(context->platformContext(), platformGradient(), m_p0, m_p1, extendOptions);
#endif
}
void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
{
if (!validateRectForCanvas(x, y, width, height))
return;
GraphicsContext* c = drawingContext();
if (!c)
return;
FloatRect rect(x, y, width, height);
willDraw(rect);
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
if (state().m_fillStyle->canvasGradient()) {
// Shading works on the entire clip region, so convert the rect to a clip.
c->save();
CGContextClipToRect(c->platformContext(), rect);
CGContextDrawShading(c->platformContext(), state().m_fillStyle->canvasGradient()->gradient().platformGradient());
c->restore();
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
CGContextFillRect(c->platformContext(), rect);
}
#elif PLATFORM(QT)
QPainter* p = static_cast<QPainter*>(c->platformContext());
if (state().m_fillStyle->canvasGradient()) {
p->fillRect(rect, QBrush(*(state().m_fillStyle->canvasGradient()->gradient().platformGradient())));
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
p->fillRect(rect, p->brush());
}
#elif PLATFORM(CAIRO) && !PLATFORM(BAL)
cairo_t* cr = c->platformContext();
cairo_save(cr);
if (state().m_fillStyle->canvasGradient()) {
cairo_set_source(cr, state().m_fillStyle->canvasGradient()->gradient().platformGradient());
} else {
if (state().m_fillStyle->pattern())
applyFillPattern();
}
cairo_rectangle(cr, x, y, width, height);
cairo_fill(cr);
cairo_restore(cr);
#elif PLATFORM(BAL)
//FIXME
notImplemented();
#endif
}
void CanvasRenderingContext2D::stroke()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
CGContextBeginPath(c->platformContext());
CGContextAddPath(c->platformContext(), state().m_path.platformPath());
if (!state().m_path.isEmpty()) {
float lineWidth = state().m_lineWidth;
float inset = -lineWidth / 2;
CGRect boundingRect = CGRectInset(CGContextGetPathBoundingBox(c->platformContext()), inset, inset);
willDraw(boundingRect);
}
if (state().m_strokeStyle->gradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextReplacePathWithStrokedPath(c->platformContext());
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_strokeStyle->gradient()->platformShading());
c->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
CGContextStrokePath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = state().m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
willDraw(path->controlPointRect());
if (state().m_strokeStyle->gradient()) {
p->save();
p->setBrush(*(state().m_strokeStyle->gradient()->platformShading()));
p->strokePath(*path, p->pen());
p->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
p->strokePath(*path, p->pen());
}
#endif
clearPathForDashboardBackwardCompatibilityMode();
}
void SVGPaintServerGradient::teardown(GraphicsContext*& context, const RenderObject* object, SVGPaintTargetType, bool isPaintingText) const
{
#if PLATFORM(CG)
// renderPath() is not used when painting text, so we paint the gradient during teardown()
if (isPaintingText && m_savedContext) {
// Restore on-screen drawing context
context = m_savedContext;
m_savedContext = 0;
clipToTextMask(context, m_imageBuffer, object, this);
// finally fill the text clip with the shading
CGContextDrawShading(context->platformContext(), m_gradient->platformGradient());
m_imageBuffer.clear(); // we're done with our text mask buffer
}
#endif
context->restore();
}
void TIPGradientRadialFillRect( CGContextRef theContext, TIPGradientRef theGradient, CGRect theRect, CGPoint center, float radius)
{
CGPoint startPoint = center;
CGPoint endPoint = center;
float startRadius = 1.0f;
float endRadius = radius;
// CoreGraphics Calls
CGContextSaveGState(theContext);
CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
CGShadingRef myCGShading = CGShadingCreateRadial(colorSpace,startPoint,startRadius,endPoint,endRadius,theGradient->gradientFunction,FALSE,FALSE);
CGContextClipToRect(theContext,theRect);
CGContextDrawShading(theContext,myCGShading);
CGShadingRelease(myCGShading);
CGColorSpaceRelease(colorSpace);
CGContextRestoreGState(theContext);
}
void TIPGradientAxialFillRect( CGContextRef theContext, TIPGradientRef theGradient, CGRect theRect, float angle)
{
CGPoint startPoint;
CGPoint endPoint;
TIPGradientFindEndpointsForRotation(theRect,angle,&startPoint,&endPoint);
// CoreGraphics Calls
CGContextSaveGState(theContext);
CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
CGShadingRef myCGShading = CGShadingCreateAxial(colorSpace,startPoint,endPoint,theGradient->gradientFunction,FALSE,FALSE);
CGContextClipToRect(theContext,theRect);
CGContextDrawShading(theContext,myCGShading);
CGShadingRelease(myCGShading);
CGColorSpaceRelease(colorSpace);
CGContextRestoreGState(theContext);
}
void CanvasRenderingContext2D::stroke()
{
GraphicsContext* c = drawingContext();
if (!c)
return;
c->beginPath();
c->addPath(m_path);
if (!m_path.isEmpty()) {
// FIXME: This is insufficient, need to use CGContextReplacePathWithStrokedPath to expand to required bounds
float lineWidth = state().m_lineWidth;
float inset = lineWidth / 2;
FloatRect boundingRect = m_path.boundingRect();
boundingRect.inflate(inset);
willDraw(boundingRect);
}
// FIXME: Do this through platform-independent GraphicsContext API.
#if PLATFORM(CG)
if (state().m_strokeStyle->canvasGradient()) {
// Shading works on the entire clip region, so convert the current path to a clip.
c->save();
CGContextReplacePathWithStrokedPath(c->platformContext());
CGContextClip(c->platformContext());
CGContextDrawShading(c->platformContext(), state().m_strokeStyle->canvasGradient()->gradient().platformGradient());
c->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
CGContextStrokePath(c->platformContext());
}
#elif PLATFORM(QT)
QPainterPath* path = m_path.platformPath();
QPainter* p = static_cast<QPainter*>(c->platformContext());
if (state().m_strokeStyle->canvasGradient()) {
p->save();
p->setBrush(*(state().m_strokeStyle->canvasGradient()->gradient().platformGradient()));
p->strokePath(*path, p->pen());
p->restore();
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
p->strokePath(*path, p->pen());
}
#elif PLATFORM(CAIRO) && !PLATFORM(BAL)
cairo_t* cr = c->platformContext();
cairo_save(cr);
if (state().m_strokeStyle->canvasGradient()) {
cairo_set_source(cr, state().m_strokeStyle->canvasGradient()->gradient().platformGradient());
c->addPath(m_path);
cairo_stroke(cr);
} else {
if (state().m_strokeStyle->pattern())
applyStrokePattern();
c->addPath(m_path);
cairo_stroke(cr);
}
cairo_restore(cr);
#elif PLATFORM(BAL)
//FIXME
notImplemented();
#endif
#if ENABLE(DASHBOARD_SUPPORT)
clearPathForDashboardBackwardCompatibilityMode();
#endif
}
