1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
* Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
* Copyright (C) 2018-2022 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#include "CommonAtomStrings.h"
#include "FEConvolveMatrix.h"
#include "SVGFilterPrimitiveStandardAttributes.h"
#include <wtf/TZoneMalloc.h>
namespace WebCore {
template<>
struct SVGPropertyTraits<EdgeModeType> {
static unsigned highestEnumValue() { return static_cast<unsigned>(EdgeModeType::None); }
static EdgeModeType initialValue() { return EdgeModeType::None; }
static String toString(EdgeModeType type)
{
switch (type) {
case EdgeModeType::Unknown:
return emptyString();
case EdgeModeType::Duplicate:
return "duplicate"_s;
case EdgeModeType::Wrap:
return "wrap"_s;
case EdgeModeType::None:
return noneAtom();
}
ASSERT_NOT_REACHED();
return emptyString();
}
static EdgeModeType fromString(SVGElement&, const String& value)
{
if (value == "duplicate"_s)
return EdgeModeType::Duplicate;
if (value == "wrap"_s)
return EdgeModeType::Wrap;
if (value == noneAtom())
return EdgeModeType::None;
return EdgeModeType::Unknown;
}
};
class SVGFEConvolveMatrixElement final : public SVGFilterPrimitiveStandardAttributes {
WTF_MAKE_TZONE_OR_ISO_ALLOCATED(SVGFEConvolveMatrixElement);
WTF_OVERRIDE_DELETE_FOR_CHECKED_PTR(SVGFEConvolveMatrixElement);
public:
static Ref<SVGFEConvolveMatrixElement> create(const QualifiedName&, Document&);
void setOrder(float orderX, float orderY);
void setKernelUnitLength(float kernelUnitLengthX, float kernelUnitLengthY);
String in1() const { return m_in1->currentValue(); }
int orderX() const { return m_orderX->currentValue(); }
int orderY() const { return m_orderY->currentValue(); }
const SVGNumberList& kernelMatrix() const { return m_kernelMatrix->currentValue(); }
float divisor() const { return m_divisor->currentValue(); }
float bias() const { return m_bias->currentValue(); }
int targetX() const { return m_targetX->currentValue(); }
int targetY() const { return m_targetY->currentValue(); }
EdgeModeType edgeMode() const { return m_edgeMode->currentValue<EdgeModeType>(); }
float kernelUnitLengthX() const { return m_kernelUnitLengthX->currentValue(); }
float kernelUnitLengthY() const { return m_kernelUnitLengthY->currentValue(); }
bool preserveAlpha() const { return m_preserveAlpha->currentValue(); }
SVGAnimatedString& in1Animated() { return m_in1; }
SVGAnimatedInteger& orderXAnimated() { return m_orderX; }
SVGAnimatedInteger& orderYAnimated() { return m_orderY; }
SVGAnimatedNumberList& kernelMatrixAnimated() { return m_kernelMatrix; }
SVGAnimatedNumber& divisorAnimated() { return m_divisor; }
SVGAnimatedNumber& biasAnimated() { return m_bias; }
SVGAnimatedInteger& targetXAnimated() { return m_targetX; }
SVGAnimatedInteger& targetYAnimated() { return m_targetY; }
SVGAnimatedEnumeration& edgeModeAnimated() { return m_edgeMode; }
SVGAnimatedNumber& kernelUnitLengthXAnimated() { return m_kernelUnitLengthX; }
SVGAnimatedNumber& kernelUnitLengthYAnimated() { return m_kernelUnitLengthY; }
SVGAnimatedBoolean& preserveAlphaAnimated() { return m_preserveAlpha; }
using PropertyRegistry = SVGPropertyOwnerRegistry<SVGFEConvolveMatrixElement, SVGFilterPrimitiveStandardAttributes>;
private:
SVGFEConvolveMatrixElement(const QualifiedName&, Document&);
static constexpr int initialOrderValue = 3;
static constexpr float initialDivisorValue = 1;
static constexpr float initialKernelUnitLengthValue = 0;
void attributeChanged(const QualifiedName&, const AtomString& oldValue, const AtomString& newValue, AttributeModificationReason) override;
void svgAttributeChanged(const QualifiedName&) override;
bool isValidTargetXOffset() const;
bool isValidTargetYOffset() const;
bool setFilterEffectAttribute(FilterEffect&, const QualifiedName&) override;
Vector<AtomString> filterEffectInputsNames() const override { return { AtomString { in1() } }; }
RefPtr<FilterEffect> createFilterEffect(const FilterEffectVector&, const GraphicsContext& destinationContext) const override;
Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };
Ref<SVGAnimatedInteger> m_orderX { SVGAnimatedInteger::create(this, initialOrderValue) };
Ref<SVGAnimatedInteger> m_orderY { SVGAnimatedInteger::create(this, initialOrderValue) };
Ref<SVGAnimatedNumberList> m_kernelMatrix { SVGAnimatedNumberList::create(this) };
Ref<SVGAnimatedNumber> m_divisor { SVGAnimatedNumber::create(this, initialDivisorValue) };
Ref<SVGAnimatedNumber> m_bias { SVGAnimatedNumber::create(this) };
Ref<SVGAnimatedInteger> m_targetX { SVGAnimatedInteger::create(this) };
Ref<SVGAnimatedInteger> m_targetY { SVGAnimatedInteger::create(this) };
Ref<SVGAnimatedEnumeration> m_edgeMode { SVGAnimatedEnumeration::create(this, EdgeModeType::Duplicate) };
Ref<SVGAnimatedNumber> m_kernelUnitLengthX { SVGAnimatedNumber::create(this) };
Ref<SVGAnimatedNumber> m_kernelUnitLengthY { SVGAnimatedNumber::create(this) };
Ref<SVGAnimatedBoolean> m_preserveAlpha { SVGAnimatedBoolean::create(this) };
};
} // namespace WebCore
|
