← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/webkit/WebCore/generated/JSSVGFECompositeElement.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/webkit/WebCore/generated/JSSVGFECompositeElement.cpp
20
20
 
21
21
#include "config.h"
22
22
 
23
 
 
24
 
#if ENABLE(SVG) && ENABLE(SVG_FILTERS)
25
 
 
26
 
#include "SVGElement.h"
 
23
#if ENABLE(SVG) && ENABLE(FILTERS)
 
24
 
27
25
#include "JSSVGFECompositeElement.h"
28
26
 
29
 
#include <wtf/GetPtr.h>
30
 
 
31
27
#include "CSSMutableStyleDeclaration.h"
32
28
#include "CSSStyleDeclaration.h"
33
29
#include "CSSValue.h"
38
34
#include "JSSVGAnimatedNumber.h"
39
35
#include "JSSVGAnimatedString.h"
40
36
#include "SVGFECompositeElement.h"
41
 
 
42
37
#include <runtime/Error.h>
43
 
#include <runtime/JSNumberCell.h>
 
38
#include <wtf/GetPtr.h>
44
39
 
45
40
using namespace JSC;
46
41
 
47
42
namespace WebCore {
48
43
 
49
 
ASSERT_CLASS_FITS_IN_CELL(JSSVGFECompositeElement)
 
44
ASSERT_CLASS_FITS_IN_CELL(JSSVGFECompositeElement);
50
45
 
51
46
/* Hash table */
52
47
 
70
65
    { 0, 0, 0, 0 }
71
66
};
72
67
 
73
 
static const HashTable JSSVGFECompositeElementTable =
 
68
static JSC_CONST_HASHTABLE HashTable JSSVGFECompositeElementTable =
74
69
#if ENABLE(PERFECT_HASH_SIZE)
75
70
    { 255, JSSVGFECompositeElementTableValues, 0 };
76
71
#else
91
86
    { 0, 0, 0, 0 }
92
87
};
93
88
 
94
 
static const HashTable JSSVGFECompositeElementConstructorTable =
 
89
static JSC_CONST_HASHTABLE HashTable JSSVGFECompositeElementConstructorTable =
95
90
#if ENABLE(PERFECT_HASH_SIZE)
96
91
    { 15, JSSVGFECompositeElementConstructorTableValues, 0 };
97
92
#else
98
93
    { 16, 15, JSSVGFECompositeElementConstructorTableValues, 0 };
99
94
#endif
100
95
 
101
 
class JSSVGFECompositeElementConstructor : public DOMObject {
 
96
class JSSVGFECompositeElementConstructor : public DOMConstructorObject {
102
97
public:
103
 
    JSSVGFECompositeElementConstructor(ExecState* exec)
104
 
        : DOMObject(JSSVGFECompositeElementConstructor::createStructure(exec->lexicalGlobalObject()->objectPrototype()))
 
98
    JSSVGFECompositeElementConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
 
99
        : DOMConstructorObject(JSSVGFECompositeElementConstructor::createStructure(globalObject->objectPrototype()), globalObject)
105
100
    {
106
 
        putDirect(exec->propertyNames().prototype, JSSVGFECompositeElementPrototype::self(exec, exec->lexicalGlobalObject()), None);
 
101
        putDirect(exec->propertyNames().prototype, JSSVGFECompositeElementPrototype::self(exec, globalObject), None);
107
102
    }
108
103
    virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 
104
    virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
109
105
    virtual const ClassInfo* classInfo() const { return &s_info; }
110
106
    static const ClassInfo s_info;
111
107
 
112
 
    static PassRefPtr<Structure> createStructure(JSValuePtr proto) 
 
108
    static PassRefPtr<Structure> createStructure(JSValue proto) 
113
109
    { 
114
110
        return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance)); 
115
111
    }
122
118
    return getStaticValueSlot<JSSVGFECompositeElementConstructor, DOMObject>(exec, &JSSVGFECompositeElementConstructorTable, this, propertyName, slot);
123
119
}
124
120
 
 
121
bool JSSVGFECompositeElementConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
122
{
 
123
    return getStaticValueDescriptor<JSSVGFECompositeElementConstructor, DOMObject>(exec, &JSSVGFECompositeElementConstructorTable, this, propertyName, descriptor);
 
124
}
 
125
 
125
126
/* Hash table for prototype */
126
127
 
127
128
static const HashTableValue JSSVGFECompositeElementPrototypeTableValues[9] =
137
138
    { 0, 0, 0, 0 }
138
139
};
139
140
 
140
 
static const HashTable JSSVGFECompositeElementPrototypeTable =
 
141
static JSC_CONST_HASHTABLE HashTable JSSVGFECompositeElementPrototypeTable =
141
142
#if ENABLE(PERFECT_HASH_SIZE)
142
143
    { 63, JSSVGFECompositeElementPrototypeTableValues, 0 };
143
144
#else
156
157
    return getStaticPropertySlot<JSSVGFECompositeElementPrototype, JSObject>(exec, &JSSVGFECompositeElementPrototypeTable, this, propertyName, slot);
157
158
}
158
159
 
 
160
bool JSSVGFECompositeElementPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
161
{
 
162
    return getStaticPropertyDescriptor<JSSVGFECompositeElementPrototype, JSObject>(exec, &JSSVGFECompositeElementPrototypeTable, this, propertyName, descriptor);
 
163
}
 
164
 
159
165
const ClassInfo JSSVGFECompositeElement::s_info = { "SVGFECompositeElement", &JSSVGElement::s_info, &JSSVGFECompositeElementTable, 0 };
160
166
 
161
 
JSSVGFECompositeElement::JSSVGFECompositeElement(PassRefPtr<Structure> structure, PassRefPtr<SVGFECompositeElement> impl)
162
 
    : JSSVGElement(structure, impl)
 
167
JSSVGFECompositeElement::JSSVGFECompositeElement(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<SVGFECompositeElement> impl)
 
168
    : JSSVGElement(structure, globalObject, impl)
163
169
{
164
170
}
165
171
 
173
179
    return getStaticValueSlot<JSSVGFECompositeElement, Base>(exec, &JSSVGFECompositeElementTable, this, propertyName, slot);
174
180
}
175
181
 
176
 
JSValuePtr jsSVGFECompositeElementIn1(ExecState* exec, const Identifier&, const PropertySlot& slot)
177
 
{
178
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
182
bool JSSVGFECompositeElement::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
183
{
 
184
    return getStaticValueDescriptor<JSSVGFECompositeElement, Base>(exec, &JSSVGFECompositeElementTable, this, propertyName, descriptor);
 
185
}
 
186
 
 
187
JSValue jsSVGFECompositeElementIn1(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
188
{
 
189
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
190
    UNUSED_PARAM(exec);
 
191
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
179
192
    RefPtr<SVGAnimatedString> obj = imp->in1Animated();
180
 
    return toJS(exec, obj.get(), imp);
 
193
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
181
194
}
182
195
 
183
 
JSValuePtr jsSVGFECompositeElementIn2(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
196
JSValue jsSVGFECompositeElementIn2(ExecState* exec, const Identifier&, const PropertySlot& slot)
184
197
{
185
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
198
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
199
    UNUSED_PARAM(exec);
 
200
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
186
201
    RefPtr<SVGAnimatedString> obj = imp->in2Animated();
187
 
    return toJS(exec, obj.get(), imp);
 
202
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
188
203
}
189
204
 
190
 
JSValuePtr jsSVGFECompositeElement_operator(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
205
JSValue jsSVGFECompositeElement_operator(ExecState* exec, const Identifier&, const PropertySlot& slot)
191
206
{
192
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
207
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
208
    UNUSED_PARAM(exec);
 
209
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
193
210
    RefPtr<SVGAnimatedEnumeration> obj = imp->_operatorAnimated();
194
 
    return toJS(exec, obj.get(), imp);
 
211
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
195
212
}
196
213
 
197
 
JSValuePtr jsSVGFECompositeElementK1(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
214
JSValue jsSVGFECompositeElementK1(ExecState* exec, const Identifier&, const PropertySlot& slot)
198
215
{
199
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
216
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
217
    UNUSED_PARAM(exec);
 
218
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
200
219
    RefPtr<SVGAnimatedNumber> obj = imp->k1Animated();
201
 
    return toJS(exec, obj.get(), imp);
 
220
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
202
221
}
203
222
 
204
 
JSValuePtr jsSVGFECompositeElementK2(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
223
JSValue jsSVGFECompositeElementK2(ExecState* exec, const Identifier&, const PropertySlot& slot)
205
224
{
206
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
225
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
226
    UNUSED_PARAM(exec);
 
227
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
207
228
    RefPtr<SVGAnimatedNumber> obj = imp->k2Animated();
208
 
    return toJS(exec, obj.get(), imp);
 
229
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
209
230
}
210
231
 
211
 
JSValuePtr jsSVGFECompositeElementK3(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
232
JSValue jsSVGFECompositeElementK3(ExecState* exec, const Identifier&, const PropertySlot& slot)
212
233
{
213
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
234
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
235
    UNUSED_PARAM(exec);
 
236
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
214
237
    RefPtr<SVGAnimatedNumber> obj = imp->k3Animated();
215
 
    return toJS(exec, obj.get(), imp);
 
238
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
216
239
}
217
240
 
218
 
JSValuePtr jsSVGFECompositeElementK4(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
241
JSValue jsSVGFECompositeElementK4(ExecState* exec, const Identifier&, const PropertySlot& slot)
219
242
{
220
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
243
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
244
    UNUSED_PARAM(exec);
 
245
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
221
246
    RefPtr<SVGAnimatedNumber> obj = imp->k4Animated();
222
 
    return toJS(exec, obj.get(), imp);
 
247
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
223
248
}
224
249
 
225
 
JSValuePtr jsSVGFECompositeElementX(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
250
JSValue jsSVGFECompositeElementX(ExecState* exec, const Identifier&, const PropertySlot& slot)
226
251
{
227
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
252
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
253
    UNUSED_PARAM(exec);
 
254
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
228
255
    RefPtr<SVGAnimatedLength> obj = imp->xAnimated();
229
 
    return toJS(exec, obj.get(), imp);
 
256
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
230
257
}
231
258
 
232
 
JSValuePtr jsSVGFECompositeElementY(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
259
JSValue jsSVGFECompositeElementY(ExecState* exec, const Identifier&, const PropertySlot& slot)
233
260
{
234
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
261
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
262
    UNUSED_PARAM(exec);
 
263
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
235
264
    RefPtr<SVGAnimatedLength> obj = imp->yAnimated();
236
 
    return toJS(exec, obj.get(), imp);
 
265
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
237
266
}
238
267
 
239
 
JSValuePtr jsSVGFECompositeElementWidth(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
268
JSValue jsSVGFECompositeElementWidth(ExecState* exec, const Identifier&, const PropertySlot& slot)
240
269
{
241
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
270
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
271
    UNUSED_PARAM(exec);
 
272
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
242
273
    RefPtr<SVGAnimatedLength> obj = imp->widthAnimated();
243
 
    return toJS(exec, obj.get(), imp);
 
274
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
244
275
}
245
276
 
246
 
JSValuePtr jsSVGFECompositeElementHeight(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
277
JSValue jsSVGFECompositeElementHeight(ExecState* exec, const Identifier&, const PropertySlot& slot)
247
278
{
248
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
279
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
280
    UNUSED_PARAM(exec);
 
281
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
249
282
    RefPtr<SVGAnimatedLength> obj = imp->heightAnimated();
250
 
    return toJS(exec, obj.get(), imp);
 
283
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
251
284
}
252
285
 
253
 
JSValuePtr jsSVGFECompositeElementResult(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
286
JSValue jsSVGFECompositeElementResult(ExecState* exec, const Identifier&, const PropertySlot& slot)
254
287
{
255
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
288
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
289
    UNUSED_PARAM(exec);
 
290
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
256
291
    RefPtr<SVGAnimatedString> obj = imp->resultAnimated();
257
 
    return toJS(exec, obj.get(), imp);
 
292
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
258
293
}
259
294
 
260
 
JSValuePtr jsSVGFECompositeElementClassName(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
295
JSValue jsSVGFECompositeElementClassName(ExecState* exec, const Identifier&, const PropertySlot& slot)
261
296
{
262
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
 
297
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
298
    UNUSED_PARAM(exec);
 
299
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
263
300
    RefPtr<SVGAnimatedString> obj = imp->classNameAnimated();
264
 
    return toJS(exec, obj.get(), imp);
265
 
}
266
 
 
267
 
JSValuePtr jsSVGFECompositeElementStyle(ExecState* exec, const Identifier&, const PropertySlot& slot)
268
 
{
269
 
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->impl());
270
 
    return toJS(exec, WTF::getPtr(imp->style()));
271
 
}
272
 
 
273
 
JSValuePtr jsSVGFECompositeElementConstructor(ExecState* exec, const Identifier&, const PropertySlot& slot)
274
 
{
275
 
    return static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()))->getConstructor(exec);
276
 
}
277
 
JSValuePtr JSSVGFECompositeElement::getConstructor(ExecState* exec)
278
 
{
279
 
    return getDOMConstructor<JSSVGFECompositeElementConstructor>(exec);
280
 
}
281
 
 
282
 
JSValuePtr jsSVGFECompositeElementPrototypeFunctionGetPresentationAttribute(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
283
 
{
284
 
    if (!thisValue->isObject(&JSSVGFECompositeElement::s_info))
 
301
    return toJS(exec, castedThis->globalObject(), obj.get(), imp);
 
302
}
 
303
 
 
304
JSValue jsSVGFECompositeElementStyle(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
305
{
 
306
    JSSVGFECompositeElement* castedThis = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
307
    UNUSED_PARAM(exec);
 
308
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThis->impl());
 
309
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->style()));
 
310
}
 
311
 
 
312
JSValue jsSVGFECompositeElementConstructor(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
313
{
 
314
    JSSVGFECompositeElement* domObject = static_cast<JSSVGFECompositeElement*>(asObject(slot.slotBase()));
 
315
    return JSSVGFECompositeElement::getConstructor(exec, domObject->globalObject());
 
316
}
 
317
JSValue JSSVGFECompositeElement::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
 
318
{
 
319
    return getDOMConstructor<JSSVGFECompositeElementConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));
 
320
}
 
321
 
 
322
JSValue JSC_HOST_CALL jsSVGFECompositeElementPrototypeFunctionGetPresentationAttribute(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
 
323
{
 
324
    UNUSED_PARAM(args);
 
325
    if (!thisValue.inherits(&JSSVGFECompositeElement::s_info))
285
326
        return throwError(exec, TypeError);
286
327
    JSSVGFECompositeElement* castedThisObj = static_cast<JSSVGFECompositeElement*>(asObject(thisValue));
287
328
    SVGFECompositeElement* imp = static_cast<SVGFECompositeElement*>(castedThisObj->impl());
288
 
    const UString& name = args.at(exec, 0)->toString(exec);
289
 
 
290
 
 
291
 
    JSC::JSValuePtr result = toJS(exec, WTF::getPtr(imp->getPresentationAttribute(name)));
 
329
    const UString& name = args.at(0).toString(exec);
 
330
 
 
331
 
 
332
    JSC::JSValue result = toJS(exec, castedThisObj->globalObject(), WTF::getPtr(imp->getPresentationAttribute(name)));
292
333
    return result;
293
334
}
294
335
 
295
336
// Constant getters
296
337
 
297
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_UNKNOWN(ExecState* exec, const Identifier&, const PropertySlot&)
 
338
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_UNKNOWN(ExecState* exec, const Identifier&, const PropertySlot&)
298
339
{
299
340
    return jsNumber(exec, static_cast<int>(0));
300
341
}
301
342
 
302
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_OVER(ExecState* exec, const Identifier&, const PropertySlot&)
 
343
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_OVER(ExecState* exec, const Identifier&, const PropertySlot&)
303
344
{
304
345
    return jsNumber(exec, static_cast<int>(1));
305
346
}
306
347
 
307
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_IN(ExecState* exec, const Identifier&, const PropertySlot&)
 
348
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_IN(ExecState* exec, const Identifier&, const PropertySlot&)
308
349
{
309
350
    return jsNumber(exec, static_cast<int>(2));
310
351
}
311
352
 
312
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_OUT(ExecState* exec, const Identifier&, const PropertySlot&)
 
353
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_OUT(ExecState* exec, const Identifier&, const PropertySlot&)
313
354
{
314
355
    return jsNumber(exec, static_cast<int>(3));
315
356
}
316
357
 
317
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_ATOP(ExecState* exec, const Identifier&, const PropertySlot&)
 
358
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_ATOP(ExecState* exec, const Identifier&, const PropertySlot&)
318
359
{
319
360
    return jsNumber(exec, static_cast<int>(4));
320
361
}
321
362
 
322
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_XOR(ExecState* exec, const Identifier&, const PropertySlot&)
 
363
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_XOR(ExecState* exec, const Identifier&, const PropertySlot&)
323
364
{
324
365
    return jsNumber(exec, static_cast<int>(5));
325
366
}
326
367
 
327
 
JSValuePtr jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_ARITHMETIC(ExecState* exec, const Identifier&, const PropertySlot&)
 
368
JSValue jsSVGFECompositeElementSVG_FECOMPOSITE_OPERATOR_ARITHMETIC(ExecState* exec, const Identifier&, const PropertySlot&)
328
369
{
329
370
    return jsNumber(exec, static_cast<int>(6));
330
371
}
332
373
 
333
374
}
334
375
 
335
 
#endif // ENABLE(SVG) && ENABLE(SVG_FILTERS)
 
376
#endif // ENABLE(SVG) && ENABLE(FILTERS)