RenderSVGResource.cpp [plain text]
#include "config.h"
#if ENABLE(SVG)
#include "RenderSVGResource.h"
#include "Frame.h"
#include "FrameView.h"
#include "RenderSVGResourceContainer.h"
#include "RenderSVGResourceFilter.h"
#include "RenderSVGResourceSolidColor.h"
#include "SVGResources.h"
#include "SVGResourcesCache.h"
#include "SVGURIReference.h"
namespace WebCore {
static inline bool inheritColorFromParentStyleIfNeeded(RenderObject* object, bool applyToFill, Color& color)
{
if (color.isValid())
return true;
if (!object->parent() || !object->parent()->style())
return false;
const SVGRenderStyle* parentSVGStyle = object->parent()->style()->svgStyle();
color = applyToFill ? parentSVGStyle->fillPaintColor() : parentSVGStyle->strokePaintColor();
return true;
}
static inline RenderSVGResource* requestPaintingResource(RenderSVGResourceMode mode, RenderObject* object, const RenderStyle* style, Color& fallbackColor)
{
ASSERT(object);
ASSERT(style);
const SVGRenderStyle* svgStyle = style->svgStyle();
if (!svgStyle)
return 0;
bool isRenderingMask = false;
if (object->frame() && object->frame()->view())
isRenderingMask = object->frame()->view()->paintBehavior() & PaintBehaviorRenderingSVGMask;
if (mode == ApplyToFillMode) {
if (isRenderingMask) {
RenderSVGResourceSolidColor* colorResource = RenderSVGResource::sharedSolidPaintingResource();
colorResource->setColor(SVGRenderStyle::initialFillPaintColor());
return colorResource;
}
if (!svgStyle->hasFill())
return 0;
} else {
if (!svgStyle->hasStroke() || isRenderingMask)
return 0;
}
bool applyToFill = mode == ApplyToFillMode;
SVGPaint::SVGPaintType paintType = applyToFill ? svgStyle->fillPaintType() : svgStyle->strokePaintType();
if (paintType == SVGPaint::SVG_PAINTTYPE_NONE)
return 0;
Color color;
switch (paintType) {
case SVGPaint::SVG_PAINTTYPE_CURRENTCOLOR:
case SVGPaint::SVG_PAINTTYPE_RGBCOLOR:
case SVGPaint::SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR:
case SVGPaint::SVG_PAINTTYPE_URI_CURRENTCOLOR:
case SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR:
case SVGPaint::SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR:
color = applyToFill ? svgStyle->fillPaintColor() : svgStyle->strokePaintColor();
default:
break;
}
if (style->insideLink() == InsideVisitedLink) {
SVGPaint::SVGPaintType visitedPaintType = applyToFill ? svgStyle->visitedLinkFillPaintType() : svgStyle->visitedLinkStrokePaintType();
if (visitedPaintType < SVGPaint::SVG_PAINTTYPE_URI_NONE && visitedPaintType != SVGPaint::SVG_PAINTTYPE_CURRENTCOLOR) {
const Color& visitedColor = applyToFill ? svgStyle->visitedLinkFillPaintColor() : svgStyle->visitedLinkStrokePaintColor();
if (visitedColor.isValid())
color = Color(visitedColor.red(), visitedColor.green(), visitedColor.blue(), color.alpha());
}
}
RenderSVGResourceSolidColor* colorResource = RenderSVGResource::sharedSolidPaintingResource();
if (paintType < SVGPaint::SVG_PAINTTYPE_URI_NONE) {
if (!inheritColorFromParentStyleIfNeeded(object, applyToFill, color))
return 0;
colorResource->setColor(color);
return colorResource;
}
SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object);
if (!resources) {
if (paintType == SVGPaint::SVG_PAINTTYPE_URI_NONE || !inheritColorFromParentStyleIfNeeded(object, applyToFill, color))
return 0;
colorResource->setColor(color);
return colorResource;
}
RenderSVGResource* uriResource = mode == ApplyToFillMode ? resources->fill() : resources->stroke();
if (!uriResource) {
if (!inheritColorFromParentStyleIfNeeded(object, applyToFill, color))
return 0;
colorResource->setColor(color);
return colorResource;
}
fallbackColor = color;
return uriResource;
}
RenderSVGResource* RenderSVGResource::fillPaintingResource(RenderObject* object, const RenderStyle* style, Color& fallbackColor)
{
return requestPaintingResource(ApplyToFillMode, object, style, fallbackColor);
}
RenderSVGResource* RenderSVGResource::strokePaintingResource(RenderObject* object, const RenderStyle* style, Color& fallbackColor)
{
return requestPaintingResource(ApplyToStrokeMode, object, style, fallbackColor);
}
RenderSVGResourceSolidColor* RenderSVGResource::sharedSolidPaintingResource()
{
static RenderSVGResourceSolidColor* s_sharedSolidPaintingResource = 0;
if (!s_sharedSolidPaintingResource)
s_sharedSolidPaintingResource = new RenderSVGResourceSolidColor;
return s_sharedSolidPaintingResource;
}
static inline void removeFromFilterCacheAndInvalidateDependencies(RenderObject* object, bool needsLayout)
{
ASSERT(object);
#if ENABLE(FILTERS)
if (SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(object)) {
if (RenderSVGResourceFilter* filter = resources->filter())
filter->removeClientFromCache(object);
}
#endif
if (!object->node() || !object->node()->isSVGElement())
return;
HashSet<SVGElement*>* dependencies = object->document()->accessSVGExtensions()->setOfElementsReferencingTarget(static_cast<SVGElement*>(object->node()));
if (!dependencies)
return;
HashSet<SVGElement*>::iterator end = dependencies->end();
for (HashSet<SVGElement*>::iterator it = dependencies->begin(); it != end; ++it) {
if (RenderObject* renderer = (*it)->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer, needsLayout);
}
}
void RenderSVGResource::markForLayoutAndParentResourceInvalidation(RenderObject* object, bool needsLayout)
{
ASSERT(object);
ASSERT(object->document());
ASSERT(object->node());
if (needsLayout)
object->setNeedsLayout(true);
removeFromFilterCacheAndInvalidateDependencies(object, needsLayout);
RenderObject* current = object->parent();
while (current) {
removeFromFilterCacheAndInvalidateDependencies(current, needsLayout);
if (current->isSVGResourceContainer()) {
current->toRenderSVGResourceContainer()->removeAllClientsFromCache();
break;
}
current = current->parent();
}
}
}
#endif