FilterOperation.cpp [plain text]
#include "config.h"
#include "FilterOperation.h"
#include "AnimationUtilities.h"
#include "CachedResourceLoader.h"
#include "CachedSVGDocumentReference.h"
#include "FilterEffect.h"
#include "SVGURIReference.h"
#include "TextStream.h"
namespace WebCore {
bool DefaultFilterOperation::operator==(const FilterOperation& operation) const
{
if (!isSameType(operation))
return false;
return representedType() == downcast<DefaultFilterOperation>(operation).representedType();
}
ReferenceFilterOperation::ReferenceFilterOperation(const String& url, const String& fragment)
: FilterOperation(REFERENCE)
, m_url(url)
, m_fragment(fragment)
{
}
ReferenceFilterOperation::~ReferenceFilterOperation()
{
}
bool ReferenceFilterOperation::operator==(const FilterOperation& operation) const
{
if (!isSameType(operation))
return false;
return m_url == downcast<ReferenceFilterOperation>(operation).m_url;
}
void ReferenceFilterOperation::loadExternalDocumentIfNeeded(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
{
if (m_cachedSVGDocumentReference)
return;
if (!SVGURIReference::isExternalURIReference(m_url, *cachedResourceLoader.document()))
return;
m_cachedSVGDocumentReference = std::make_unique<CachedSVGDocumentReference>(m_url);
m_cachedSVGDocumentReference->load(cachedResourceLoader, options);
}
void ReferenceFilterOperation::setFilterEffect(RefPtr<FilterEffect>&& filterEffect)
{
m_filterEffect = WTFMove(filterEffect);
}
RefPtr<FilterOperation> BasicColorMatrixFilterOperation::blend(const FilterOperation* from, double progress, bool blendToPassthrough)
{
if (from && !from->isSameType(*this))
return this;
if (blendToPassthrough)
return BasicColorMatrixFilterOperation::create(WebCore::blend(m_amount, passthroughAmount(), progress), m_type);
const BasicColorMatrixFilterOperation* fromOperation = downcast<BasicColorMatrixFilterOperation>(from);
double fromAmount = fromOperation ? fromOperation->amount() : passthroughAmount();
return BasicColorMatrixFilterOperation::create(WebCore::blend(fromAmount, m_amount, progress), m_type);
}
inline bool BasicColorMatrixFilterOperation::operator==(const FilterOperation& operation) const
{
if (!isSameType(operation))
return false;
const BasicColorMatrixFilterOperation& other = downcast<BasicColorMatrixFilterOperation>(operation);
return m_amount == other.m_amount;
}
double BasicColorMatrixFilterOperation::passthroughAmount() const
{
switch (m_type) {
case GRAYSCALE:
case SEPIA:
case HUE_ROTATE:
return 0;
case SATURATE:
return 1;
default:
ASSERT_NOT_REACHED();
return 0;
}
}
RefPtr<FilterOperation> BasicComponentTransferFilterOperation::blend(const FilterOperation* from, double progress, bool blendToPassthrough)
{
if (from && !from->isSameType(*this))
return this;
if (blendToPassthrough)
return BasicComponentTransferFilterOperation::create(WebCore::blend(m_amount, passthroughAmount(), progress), m_type);
const BasicComponentTransferFilterOperation* fromOperation = downcast<BasicComponentTransferFilterOperation>(from);
double fromAmount = fromOperation ? fromOperation->amount() : passthroughAmount();
return BasicComponentTransferFilterOperation::create(WebCore::blend(fromAmount, m_amount, progress), m_type);
}
inline bool BasicComponentTransferFilterOperation::operator==(const FilterOperation& operation) const
{
if (!isSameType(operation))
return false;
const BasicComponentTransferFilterOperation& other = downcast<BasicComponentTransferFilterOperation>(operation);
return m_amount == other.m_amount;
}
double BasicComponentTransferFilterOperation::passthroughAmount() const
{
switch (m_type) {
case OPACITY:
return 1;
case INVERT:
return 0;
case CONTRAST:
return 1;
case BRIGHTNESS:
return 1;
default:
ASSERT_NOT_REACHED();
return 0;
}
}
bool BlurFilterOperation::operator==(const FilterOperation& operation) const
{
if (!isSameType(operation))
return false;
return m_stdDeviation == downcast<BlurFilterOperation>(operation).stdDeviation();
}
RefPtr<FilterOperation> BlurFilterOperation::blend(const FilterOperation* from, double progress, bool blendToPassthrough)
{
if (from && !from->isSameType(*this))
return this;
LengthType lengthType = m_stdDeviation.type();
if (blendToPassthrough)
return BlurFilterOperation::create(WebCore::blend(m_stdDeviation, Length(lengthType), progress));
const BlurFilterOperation* fromOperation = downcast<BlurFilterOperation>(from);
Length fromLength = fromOperation ? fromOperation->m_stdDeviation : Length(lengthType);
return BlurFilterOperation::create(WebCore::blend(fromLength, m_stdDeviation, progress));
}
bool DropShadowFilterOperation::operator==(const FilterOperation& operation) const
{
if (!isSameType(operation))
return false;
const DropShadowFilterOperation& other = downcast<DropShadowFilterOperation>(operation);
return m_location == other.m_location && m_stdDeviation == other.m_stdDeviation && m_color == other.m_color;
}
RefPtr<FilterOperation> DropShadowFilterOperation::blend(const FilterOperation* from, double progress, bool blendToPassthrough)
{
if (from && !from->isSameType(*this))
return this;
if (blendToPassthrough)
return DropShadowFilterOperation::create(
WebCore::blend(m_location, IntPoint(), progress),
WebCore::blend(m_stdDeviation, 0, progress),
WebCore::blend(m_color, Color(Color::transparent), progress));
const DropShadowFilterOperation* fromOperation = downcast<DropShadowFilterOperation>(from);
IntPoint fromLocation = fromOperation ? fromOperation->location() : IntPoint();
int fromStdDeviation = fromOperation ? fromOperation->stdDeviation() : 0;
Color fromColor = fromOperation ? fromOperation->color() : Color(Color::transparent);
return DropShadowFilterOperation::create(
WebCore::blend(fromLocation, m_location, progress),
WebCore::blend(fromStdDeviation, m_stdDeviation, progress),
WebCore::blend(fromColor, m_color, progress));
}
TextStream& operator<<(TextStream& ts, const FilterOperation& filter)
{
switch (filter.type()) {
case FilterOperation::REFERENCE:
ts << "reference";
break;
case FilterOperation::GRAYSCALE: {
const auto& colorMatrixFilter = downcast<BasicColorMatrixFilterOperation>(filter);
ts << "grayscale(" << colorMatrixFilter.amount() << ")";
break;
}
case FilterOperation::SEPIA: {
const auto& colorMatrixFilter = downcast<BasicColorMatrixFilterOperation>(filter);
ts << "sepia(" << colorMatrixFilter.amount() << ")";
break;
}
case FilterOperation::SATURATE: {
const auto& colorMatrixFilter = downcast<BasicColorMatrixFilterOperation>(filter);
ts << "saturate(" << colorMatrixFilter.amount() << ")";
break;
}
case FilterOperation::HUE_ROTATE: {
const auto& colorMatrixFilter = downcast<BasicColorMatrixFilterOperation>(filter);
ts << "hue-rotate(" << colorMatrixFilter.amount() << ")";
break;
}
case FilterOperation::INVERT: {
const auto& componentTransferFilter = downcast<BasicComponentTransferFilterOperation>(filter);
ts << "invert(" << componentTransferFilter.amount() << ")";
break;
}
case FilterOperation::OPACITY: {
const auto& componentTransferFilter = downcast<BasicComponentTransferFilterOperation>(filter);
ts << "opacity(" << componentTransferFilter.amount() << ")";
break;
}
case FilterOperation::BRIGHTNESS: {
const auto& componentTransferFilter = downcast<BasicComponentTransferFilterOperation>(filter);
ts << "brightness(" << componentTransferFilter.amount() << ")";
break;
}
case FilterOperation::CONTRAST: {
const auto& componentTransferFilter = downcast<BasicComponentTransferFilterOperation>(filter);
ts << "contrast(" << componentTransferFilter.amount() << ")";
break;
}
case FilterOperation::BLUR: {
const auto& blurFilter = downcast<BlurFilterOperation>(filter);
ts << "blur(" << blurFilter.stdDeviation().value() << ")"; break;
}
case FilterOperation::DROP_SHADOW: {
const auto& dropShadowFilter = downcast<DropShadowFilterOperation>(filter);
ts << "drop-shadow(" << dropShadowFilter.x() << " " << dropShadowFilter.y() << " " << dropShadowFilter.location() << " ";
ts << dropShadowFilter.color() << ")";
break;
}
case FilterOperation::PASSTHROUGH:
ts << "passthrough";
break;
case FilterOperation::DEFAULT: {
const auto& defaultFilter = downcast<DefaultFilterOperation>(filter);
ts << "default type=" << (int)defaultFilter.representedType();
break;
}
case FilterOperation::NONE:
ts << "none";
break;
}
return ts;
}
}