SVGPaintServerGradient.cpp [plain text]
#include "config.h"
#if ENABLE(SVG)
#include "SVGPaintServerGradient.h"
#include "FloatConversion.h"
#include "GraphicsContext.h"
#include "ImageBuffer.h"
#include "RenderObject.h"
#include "RenderView.h"
#include "SVGGradientElement.h"
#include "SVGPaintServerLinearGradient.h"
#include "SVGPaintServerRadialGradient.h"
#include "SVGRenderSupport.h"
#include "SVGRenderTreeAsText.h"
using namespace std;
namespace WebCore {
static TextStream& operator<<(TextStream& ts, GradientSpreadMethod m)
{
switch (m) {
case SpreadMethodPad:
ts << "PAD"; break;
case SpreadMethodRepeat:
ts << "REPEAT"; break;
case SpreadMethodReflect:
ts << "REFLECT"; break;
}
return ts;
}
static TextStream& operator<<(TextStream& ts, const Vector<SVGGradientStop>& l)
{
ts << "[";
for (Vector<SVGGradientStop>::const_iterator it = l.begin(); it != l.end(); ++it) {
ts << "(" << it->first << "," << it->second << ")";
if (it + 1 != l.end())
ts << ", ";
}
ts << "]";
return ts;
}
SVGPaintServerGradient::SVGPaintServerGradient(const SVGGradientElement* owner)
: m_boundingBoxMode(true)
, m_ownerElement(owner)
#if PLATFORM(CG)
, m_savedContext(0)
, m_imageBuffer(0)
#endif
{
ASSERT(owner);
}
SVGPaintServerGradient::~SVGPaintServerGradient()
{
}
Gradient* SVGPaintServerGradient::gradient() const
{
return m_gradient.get();
}
void SVGPaintServerGradient::setGradient(PassRefPtr<Gradient> gradient)
{
m_gradient = gradient;
}
bool SVGPaintServerGradient::boundingBoxMode() const
{
return m_boundingBoxMode;
}
void SVGPaintServerGradient::setBoundingBoxMode(bool mode)
{
m_boundingBoxMode = mode;
}
TransformationMatrix SVGPaintServerGradient::gradientTransform() const
{
return m_gradientTransform;
}
void SVGPaintServerGradient::setGradientTransform(const TransformationMatrix& transform)
{
m_gradientTransform = transform;
}
#if PLATFORM(CG)
static inline const RenderObject* findTextRootObject(const RenderObject* start)
{
while (start && !start->isSVGText())
start = start->parent();
ASSERT(start);
ASSERT(start->isSVGText());
return start;
}
static inline TransformationMatrix absoluteTransformForRenderer(const RenderObject* object)
{
TransformationMatrix absoluteTransform;
const RenderObject* currentObject = object;
while (currentObject) {
absoluteTransform = currentObject->localToParentTransform() * absoluteTransform;
currentObject = currentObject->parent();
}
return absoluteTransform;
}
static inline bool createMaskAndSwapContextForTextGradient(
GraphicsContext*& context, GraphicsContext*& savedContext,
OwnPtr<ImageBuffer>& imageBuffer, const RenderObject* object)
{
const RenderObject* textRootBlock = findTextRootObject(object);
TransformationMatrix transform = absoluteTransformForRenderer(textRootBlock);
FloatRect maskAbsoluteBoundingBox = transform.mapRect(textRootBlock->repaintRectInLocalCoordinates());
IntRect maskImageRect = enclosingIntRect(maskAbsoluteBoundingBox);
if (maskImageRect.isEmpty())
return false;
OwnPtr<ImageBuffer> maskImage = ImageBuffer::create(maskImageRect.size());
if (!maskImage)
return false;
GraphicsContext* maskImageContext = maskImage->context();
maskImageContext->translate(-maskAbsoluteBoundingBox.x(), -maskAbsoluteBoundingBox.y());
maskImageContext->concatCTM(transform);
imageBuffer.set(maskImage.release());
savedContext = context;
context = maskImageContext;
return true;
}
static inline TransformationMatrix clipToTextMask(GraphicsContext* context,
OwnPtr<ImageBuffer>& imageBuffer, const RenderObject* object,
const SVGPaintServerGradient* gradientServer)
{
const RenderObject* textRootBlock = findTextRootObject(object);
context->clipToImageBuffer(textRootBlock->repaintRectInLocalCoordinates(), imageBuffer.get());
TransformationMatrix matrix;
if (gradientServer->boundingBoxMode()) {
FloatRect maskBoundingBox = textRootBlock->objectBoundingBox();
matrix.translate(maskBoundingBox.x(), maskBoundingBox.y());
matrix.scaleNonUniform(maskBoundingBox.width(), maskBoundingBox.height());
}
matrix.multiply(gradientServer->gradientTransform());
return matrix;
}
#endif
bool SVGPaintServerGradient::setup(GraphicsContext*& context, const RenderObject* object, SVGPaintTargetType type, bool isPaintingText) const
{
m_ownerElement->buildGradient();
const SVGRenderStyle* style = object->style()->svgStyle();
bool isFilled = (type & ApplyToFillTargetType) && style->hasFill();
bool isStroked = (type & ApplyToStrokeTargetType) && style->hasStroke();
ASSERT((isFilled && !isStroked) || (!isFilled && isStroked));
context->save();
if (isPaintingText) {
#if PLATFORM(CG)
if (!createMaskAndSwapContextForTextGradient(context, m_savedContext, m_imageBuffer, object)) {
context->restore();
return false;
}
#endif
context->setTextDrawingMode(isFilled ? cTextFill : cTextStroke);
}
if (isFilled) {
context->setAlpha(style->fillOpacity());
context->setFillGradient(m_gradient);
context->setFillRule(style->fillRule());
}
if (isStroked) {
context->setAlpha(style->strokeOpacity());
context->setStrokeGradient(m_gradient);
applyStrokeStyleToContext(context, object->style(), object);
}
TransformationMatrix matrix;
#if PLATFORM(CG)
if (boundingBoxMode() && !isPaintingText) {
#else
if (boundingBoxMode()) {
#endif
FloatRect bbox = object->objectBoundingBox();
if (bbox.width() == 0 || bbox.height() == 0) {
Color color(0, 0, 0);
context->setStrokeColor(color, object->style()->colorSpace());
return true;
}
matrix.translate(bbox.x(), bbox.y());
matrix.scaleNonUniform(bbox.width(), bbox.height());
}
matrix.multiply(gradientTransform());
m_gradient->setGradientSpaceTransform(matrix);
return true;
}
void SVGPaintServerGradient::teardown(GraphicsContext*& context, const RenderObject* object, SVGPaintTargetType, bool isPaintingText) const
{
#if PLATFORM(CG)
if (isPaintingText && m_savedContext) {
context = m_savedContext;
m_savedContext = 0;
TransformationMatrix matrix = clipToTextMask(context, m_imageBuffer, object, this);
m_gradient->setGradientSpaceTransform(matrix);
context->setFillGradient(m_gradient);
const RenderObject* textRootBlock = findTextRootObject(object);
context->fillRect(textRootBlock->repaintRectInLocalCoordinates());
m_imageBuffer.clear();
}
#endif
context->restore();
}
TextStream& SVGPaintServerGradient::externalRepresentation(TextStream& ts) const
{
m_ownerElement->buildGradient();
ts << "[stops=" << gradientStops() << "]";
if (m_gradient->spreadMethod() != SpreadMethodPad)
ts << "[method=" << m_gradient->spreadMethod() << "]";
if (!boundingBoxMode())
ts << " [bounding box mode=" << boundingBoxMode() << "]";
if (!gradientTransform().isIdentity())
ts << " [transform=" << gradientTransform() << "]";
return ts;
}
}
#endif