← 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/JSSVGElementInstance.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/JSSVGElementInstance.cpp
20
20
 
21
21
#include "config.h"
22
22
 
23
 
 
24
23
#if ENABLE(SVG)
25
24
 
26
 
#include "SVGElement.h"
27
25
#include "JSSVGElementInstance.h"
28
26
 
29
 
#include <wtf/GetPtr.h>
30
 
 
31
27
#include "Event.h"
32
28
#include "EventListener.h"
33
29
#include "Frame.h"
42
38
#include "SVGElementInstance.h"
43
39
#include "SVGElementInstanceList.h"
44
40
#include "SVGUseElement.h"
45
 
 
46
41
#include <runtime/Error.h>
 
42
#include <wtf/GetPtr.h>
47
43
 
48
44
using namespace JSC;
49
45
 
50
46
namespace WebCore {
51
47
 
52
 
ASSERT_CLASS_FITS_IN_CELL(JSSVGElementInstance)
 
48
ASSERT_CLASS_FITS_IN_CELL(JSSVGElementInstance);
53
49
 
54
50
/* Hash table */
55
51
 
106
102
    { 0, 0, 0, 0 }
107
103
};
108
104
 
109
 
static const HashTable JSSVGElementInstanceTable =
 
105
static JSC_CONST_HASHTABLE HashTable JSSVGElementInstanceTable =
110
106
#if ENABLE(PERFECT_HASH_SIZE)
111
107
    { 4095, JSSVGElementInstanceTableValues, 0 };
112
108
#else
123
119
    { 0, 0, 0, 0 }
124
120
};
125
121
 
126
 
static const HashTable JSSVGElementInstancePrototypeTable =
 
122
static JSC_CONST_HASHTABLE HashTable JSSVGElementInstancePrototypeTable =
127
123
#if ENABLE(PERFECT_HASH_SIZE)
128
124
    { 3, JSSVGElementInstancePrototypeTableValues, 0 };
129
125
#else
142
138
    return getStaticFunctionSlot<JSObject>(exec, &JSSVGElementInstancePrototypeTable, this, propertyName, slot);
143
139
}
144
140
 
 
141
bool JSSVGElementInstancePrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
142
{
 
143
    return getStaticFunctionDescriptor<JSObject>(exec, &JSSVGElementInstancePrototypeTable, this, propertyName, descriptor);
 
144
}
 
145
 
145
146
const ClassInfo JSSVGElementInstance::s_info = { "SVGElementInstance", 0, &JSSVGElementInstanceTable, 0 };
146
147
 
147
 
JSSVGElementInstance::JSSVGElementInstance(PassRefPtr<Structure> structure, PassRefPtr<SVGElementInstance> impl)
148
 
    : DOMObject(structure)
 
148
JSSVGElementInstance::JSSVGElementInstance(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<SVGElementInstance> impl)
 
149
    : DOMObjectWithGlobalPointer(structure, globalObject)
149
150
    , m_impl(impl)
150
151
{
151
152
}
152
153
 
153
154
JSSVGElementInstance::~JSSVGElementInstance()
154
155
{
155
 
    forgetDOMObject(*Heap::heap(this)->globalData(), m_impl.get());
156
 
 
 
156
    forgetDOMObject(*Heap::heap(this)->globalData(), impl());
157
157
}
158
158
 
159
159
JSObject* JSSVGElementInstance::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
166
166
    return getStaticValueSlot<JSSVGElementInstance, Base>(exec, &JSSVGElementInstanceTable, this, propertyName, slot);
167
167
}
168
168
 
169
 
JSValuePtr jsSVGElementInstanceCorrespondingElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
170
 
{
171
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
172
 
    return toJS(exec, WTF::getPtr(imp->correspondingElement()));
173
 
}
174
 
 
175
 
JSValuePtr jsSVGElementInstanceCorrespondingUseElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
176
 
{
177
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
178
 
    return toJS(exec, WTF::getPtr(imp->correspondingUseElement()));
179
 
}
180
 
 
181
 
JSValuePtr jsSVGElementInstanceParentNode(ExecState* exec, const Identifier&, const PropertySlot& slot)
182
 
{
183
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
184
 
    return toJS(exec, WTF::getPtr(imp->parentNode()));
185
 
}
186
 
 
187
 
JSValuePtr jsSVGElementInstanceChildNodes(ExecState* exec, const Identifier&, const PropertySlot& slot)
188
 
{
189
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
190
 
    return toJS(exec, WTF::getPtr(imp->childNodes()));
191
 
}
192
 
 
193
 
JSValuePtr jsSVGElementInstanceFirstChild(ExecState* exec, const Identifier&, const PropertySlot& slot)
194
 
{
195
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
196
 
    return toJS(exec, WTF::getPtr(imp->firstChild()));
197
 
}
198
 
 
199
 
JSValuePtr jsSVGElementInstanceLastChild(ExecState* exec, const Identifier&, const PropertySlot& slot)
200
 
{
201
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
202
 
    return toJS(exec, WTF::getPtr(imp->lastChild()));
203
 
}
204
 
 
205
 
JSValuePtr jsSVGElementInstancePreviousSibling(ExecState* exec, const Identifier&, const PropertySlot& slot)
206
 
{
207
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
208
 
    return toJS(exec, WTF::getPtr(imp->previousSibling()));
209
 
}
210
 
 
211
 
JSValuePtr jsSVGElementInstanceNextSibling(ExecState* exec, const Identifier&, const PropertySlot& slot)
212
 
{
213
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
214
 
    return toJS(exec, WTF::getPtr(imp->nextSibling()));
215
 
}
216
 
 
217
 
JSValuePtr jsSVGElementInstanceOnabort(ExecState* exec, const Identifier&, const PropertySlot& slot)
218
 
{
219
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
220
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onabort())) {
221
 
        if (JSObject* listenerObj = listener->listenerObj())
222
 
            return listenerObj;
223
 
    }
224
 
    return jsNull();
225
 
}
226
 
 
227
 
JSValuePtr jsSVGElementInstanceOnblur(ExecState* exec, const Identifier&, const PropertySlot& slot)
228
 
{
229
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
230
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onblur())) {
231
 
        if (JSObject* listenerObj = listener->listenerObj())
232
 
            return listenerObj;
233
 
    }
234
 
    return jsNull();
235
 
}
236
 
 
237
 
JSValuePtr jsSVGElementInstanceOnchange(ExecState* exec, const Identifier&, const PropertySlot& slot)
238
 
{
239
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
240
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onchange())) {
241
 
        if (JSObject* listenerObj = listener->listenerObj())
242
 
            return listenerObj;
243
 
    }
244
 
    return jsNull();
245
 
}
246
 
 
247
 
JSValuePtr jsSVGElementInstanceOnclick(ExecState* exec, const Identifier&, const PropertySlot& slot)
248
 
{
249
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
250
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onclick())) {
251
 
        if (JSObject* listenerObj = listener->listenerObj())
252
 
            return listenerObj;
253
 
    }
254
 
    return jsNull();
255
 
}
256
 
 
257
 
JSValuePtr jsSVGElementInstanceOncontextmenu(ExecState* exec, const Identifier&, const PropertySlot& slot)
258
 
{
259
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
260
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->oncontextmenu())) {
261
 
        if (JSObject* listenerObj = listener->listenerObj())
262
 
            return listenerObj;
263
 
    }
264
 
    return jsNull();
265
 
}
266
 
 
267
 
JSValuePtr jsSVGElementInstanceOndblclick(ExecState* exec, const Identifier&, const PropertySlot& slot)
268
 
{
269
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
270
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondblclick())) {
271
 
        if (JSObject* listenerObj = listener->listenerObj())
272
 
            return listenerObj;
273
 
    }
274
 
    return jsNull();
275
 
}
276
 
 
277
 
JSValuePtr jsSVGElementInstanceOnerror(ExecState* exec, const Identifier&, const PropertySlot& slot)
278
 
{
279
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
280
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onerror())) {
281
 
        if (JSObject* listenerObj = listener->listenerObj())
282
 
            return listenerObj;
283
 
    }
284
 
    return jsNull();
285
 
}
286
 
 
287
 
JSValuePtr jsSVGElementInstanceOnfocus(ExecState* exec, const Identifier&, const PropertySlot& slot)
288
 
{
289
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
290
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onfocus())) {
291
 
        if (JSObject* listenerObj = listener->listenerObj())
292
 
            return listenerObj;
293
 
    }
294
 
    return jsNull();
295
 
}
296
 
 
297
 
JSValuePtr jsSVGElementInstanceOninput(ExecState* exec, const Identifier&, const PropertySlot& slot)
298
 
{
299
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
300
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->oninput())) {
301
 
        if (JSObject* listenerObj = listener->listenerObj())
302
 
            return listenerObj;
303
 
    }
304
 
    return jsNull();
305
 
}
306
 
 
307
 
JSValuePtr jsSVGElementInstanceOnkeydown(ExecState* exec, const Identifier&, const PropertySlot& slot)
308
 
{
309
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
310
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onkeydown())) {
311
 
        if (JSObject* listenerObj = listener->listenerObj())
312
 
            return listenerObj;
313
 
    }
314
 
    return jsNull();
315
 
}
316
 
 
317
 
JSValuePtr jsSVGElementInstanceOnkeypress(ExecState* exec, const Identifier&, const PropertySlot& slot)
318
 
{
319
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
320
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onkeypress())) {
321
 
        if (JSObject* listenerObj = listener->listenerObj())
322
 
            return listenerObj;
323
 
    }
324
 
    return jsNull();
325
 
}
326
 
 
327
 
JSValuePtr jsSVGElementInstanceOnkeyup(ExecState* exec, const Identifier&, const PropertySlot& slot)
328
 
{
329
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
330
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onkeyup())) {
331
 
        if (JSObject* listenerObj = listener->listenerObj())
332
 
            return listenerObj;
333
 
    }
334
 
    return jsNull();
335
 
}
336
 
 
337
 
JSValuePtr jsSVGElementInstanceOnload(ExecState* exec, const Identifier&, const PropertySlot& slot)
338
 
{
339
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
340
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onload())) {
341
 
        if (JSObject* listenerObj = listener->listenerObj())
342
 
            return listenerObj;
343
 
    }
344
 
    return jsNull();
345
 
}
346
 
 
347
 
JSValuePtr jsSVGElementInstanceOnmousedown(ExecState* exec, const Identifier&, const PropertySlot& slot)
348
 
{
349
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
350
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onmousedown())) {
351
 
        if (JSObject* listenerObj = listener->listenerObj())
352
 
            return listenerObj;
353
 
    }
354
 
    return jsNull();
355
 
}
356
 
 
357
 
JSValuePtr jsSVGElementInstanceOnmousemove(ExecState* exec, const Identifier&, const PropertySlot& slot)
358
 
{
359
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
360
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onmousemove())) {
361
 
        if (JSObject* listenerObj = listener->listenerObj())
362
 
            return listenerObj;
363
 
    }
364
 
    return jsNull();
365
 
}
366
 
 
367
 
JSValuePtr jsSVGElementInstanceOnmouseout(ExecState* exec, const Identifier&, const PropertySlot& slot)
368
 
{
369
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
370
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onmouseout())) {
371
 
        if (JSObject* listenerObj = listener->listenerObj())
372
 
            return listenerObj;
373
 
    }
374
 
    return jsNull();
375
 
}
376
 
 
377
 
JSValuePtr jsSVGElementInstanceOnmouseover(ExecState* exec, const Identifier&, const PropertySlot& slot)
378
 
{
379
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
380
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onmouseover())) {
381
 
        if (JSObject* listenerObj = listener->listenerObj())
382
 
            return listenerObj;
383
 
    }
384
 
    return jsNull();
385
 
}
386
 
 
387
 
JSValuePtr jsSVGElementInstanceOnmouseup(ExecState* exec, const Identifier&, const PropertySlot& slot)
388
 
{
389
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
390
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onmouseup())) {
391
 
        if (JSObject* listenerObj = listener->listenerObj())
392
 
            return listenerObj;
393
 
    }
394
 
    return jsNull();
395
 
}
396
 
 
397
 
JSValuePtr jsSVGElementInstanceOnmousewheel(ExecState* exec, const Identifier&, const PropertySlot& slot)
398
 
{
399
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
400
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onmousewheel())) {
401
 
        if (JSObject* listenerObj = listener->listenerObj())
402
 
            return listenerObj;
403
 
    }
404
 
    return jsNull();
405
 
}
406
 
 
407
 
JSValuePtr jsSVGElementInstanceOnbeforecut(ExecState* exec, const Identifier&, const PropertySlot& slot)
408
 
{
409
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
410
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onbeforecut())) {
411
 
        if (JSObject* listenerObj = listener->listenerObj())
412
 
            return listenerObj;
413
 
    }
414
 
    return jsNull();
415
 
}
416
 
 
417
 
JSValuePtr jsSVGElementInstanceOncut(ExecState* exec, const Identifier&, const PropertySlot& slot)
418
 
{
419
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
420
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->oncut())) {
421
 
        if (JSObject* listenerObj = listener->listenerObj())
422
 
            return listenerObj;
423
 
    }
424
 
    return jsNull();
425
 
}
426
 
 
427
 
JSValuePtr jsSVGElementInstanceOnbeforecopy(ExecState* exec, const Identifier&, const PropertySlot& slot)
428
 
{
429
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
430
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onbeforecopy())) {
431
 
        if (JSObject* listenerObj = listener->listenerObj())
432
 
            return listenerObj;
433
 
    }
434
 
    return jsNull();
435
 
}
436
 
 
437
 
JSValuePtr jsSVGElementInstanceOncopy(ExecState* exec, const Identifier&, const PropertySlot& slot)
438
 
{
439
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
440
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->oncopy())) {
441
 
        if (JSObject* listenerObj = listener->listenerObj())
442
 
            return listenerObj;
443
 
    }
444
 
    return jsNull();
445
 
}
446
 
 
447
 
JSValuePtr jsSVGElementInstanceOnbeforepaste(ExecState* exec, const Identifier&, const PropertySlot& slot)
448
 
{
449
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
450
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onbeforepaste())) {
451
 
        if (JSObject* listenerObj = listener->listenerObj())
452
 
            return listenerObj;
453
 
    }
454
 
    return jsNull();
455
 
}
456
 
 
457
 
JSValuePtr jsSVGElementInstanceOnpaste(ExecState* exec, const Identifier&, const PropertySlot& slot)
458
 
{
459
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
460
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onpaste())) {
461
 
        if (JSObject* listenerObj = listener->listenerObj())
462
 
            return listenerObj;
463
 
    }
464
 
    return jsNull();
465
 
}
466
 
 
467
 
JSValuePtr jsSVGElementInstanceOndragenter(ExecState* exec, const Identifier&, const PropertySlot& slot)
468
 
{
469
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
470
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondragenter())) {
471
 
        if (JSObject* listenerObj = listener->listenerObj())
472
 
            return listenerObj;
473
 
    }
474
 
    return jsNull();
475
 
}
476
 
 
477
 
JSValuePtr jsSVGElementInstanceOndragover(ExecState* exec, const Identifier&, const PropertySlot& slot)
478
 
{
479
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
480
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondragover())) {
481
 
        if (JSObject* listenerObj = listener->listenerObj())
482
 
            return listenerObj;
483
 
    }
484
 
    return jsNull();
485
 
}
486
 
 
487
 
JSValuePtr jsSVGElementInstanceOndragleave(ExecState* exec, const Identifier&, const PropertySlot& slot)
488
 
{
489
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
490
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondragleave())) {
491
 
        if (JSObject* listenerObj = listener->listenerObj())
492
 
            return listenerObj;
493
 
    }
494
 
    return jsNull();
495
 
}
496
 
 
497
 
JSValuePtr jsSVGElementInstanceOndrop(ExecState* exec, const Identifier&, const PropertySlot& slot)
498
 
{
499
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
500
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondrop())) {
501
 
        if (JSObject* listenerObj = listener->listenerObj())
502
 
            return listenerObj;
503
 
    }
504
 
    return jsNull();
505
 
}
506
 
 
507
 
JSValuePtr jsSVGElementInstanceOndragstart(ExecState* exec, const Identifier&, const PropertySlot& slot)
508
 
{
509
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
510
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondragstart())) {
511
 
        if (JSObject* listenerObj = listener->listenerObj())
512
 
            return listenerObj;
513
 
    }
514
 
    return jsNull();
515
 
}
516
 
 
517
 
JSValuePtr jsSVGElementInstanceOndrag(ExecState* exec, const Identifier&, const PropertySlot& slot)
518
 
{
519
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
520
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondrag())) {
521
 
        if (JSObject* listenerObj = listener->listenerObj())
522
 
            return listenerObj;
523
 
    }
524
 
    return jsNull();
525
 
}
526
 
 
527
 
JSValuePtr jsSVGElementInstanceOndragend(ExecState* exec, const Identifier&, const PropertySlot& slot)
528
 
{
529
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
530
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->ondragend())) {
531
 
        if (JSObject* listenerObj = listener->listenerObj())
532
 
            return listenerObj;
533
 
    }
534
 
    return jsNull();
535
 
}
536
 
 
537
 
JSValuePtr jsSVGElementInstanceOnreset(ExecState* exec, const Identifier&, const PropertySlot& slot)
538
 
{
539
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
540
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onreset())) {
541
 
        if (JSObject* listenerObj = listener->listenerObj())
542
 
            return listenerObj;
543
 
    }
544
 
    return jsNull();
545
 
}
546
 
 
547
 
JSValuePtr jsSVGElementInstanceOnresize(ExecState* exec, const Identifier&, const PropertySlot& slot)
548
 
{
549
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
550
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onresize())) {
551
 
        if (JSObject* listenerObj = listener->listenerObj())
552
 
            return listenerObj;
553
 
    }
554
 
    return jsNull();
555
 
}
556
 
 
557
 
JSValuePtr jsSVGElementInstanceOnscroll(ExecState* exec, const Identifier&, const PropertySlot& slot)
558
 
{
559
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
560
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onscroll())) {
561
 
        if (JSObject* listenerObj = listener->listenerObj())
562
 
            return listenerObj;
563
 
    }
564
 
    return jsNull();
565
 
}
566
 
 
567
 
JSValuePtr jsSVGElementInstanceOnsearch(ExecState* exec, const Identifier&, const PropertySlot& slot)
568
 
{
569
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
570
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onsearch())) {
571
 
        if (JSObject* listenerObj = listener->listenerObj())
572
 
            return listenerObj;
573
 
    }
574
 
    return jsNull();
575
 
}
576
 
 
577
 
JSValuePtr jsSVGElementInstanceOnselect(ExecState* exec, const Identifier&, const PropertySlot& slot)
578
 
{
579
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
580
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onselect())) {
581
 
        if (JSObject* listenerObj = listener->listenerObj())
582
 
            return listenerObj;
583
 
    }
584
 
    return jsNull();
585
 
}
586
 
 
587
 
JSValuePtr jsSVGElementInstanceOnselectstart(ExecState* exec, const Identifier&, const PropertySlot& slot)
588
 
{
589
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
590
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onselectstart())) {
591
 
        if (JSObject* listenerObj = listener->listenerObj())
592
 
            return listenerObj;
593
 
    }
594
 
    return jsNull();
595
 
}
596
 
 
597
 
JSValuePtr jsSVGElementInstanceOnsubmit(ExecState* exec, const Identifier&, const PropertySlot& slot)
598
 
{
599
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
600
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onsubmit())) {
601
 
        if (JSObject* listenerObj = listener->listenerObj())
602
 
            return listenerObj;
603
 
    }
604
 
    return jsNull();
605
 
}
606
 
 
607
 
JSValuePtr jsSVGElementInstanceOnunload(ExecState* exec, const Identifier&, const PropertySlot& slot)
608
 
{
609
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()))->impl());
610
 
    if (JSEventListener* listener = static_cast<JSEventListener*>(imp->onunload())) {
611
 
        if (JSObject* listenerObj = listener->listenerObj())
612
 
            return listenerObj;
613
 
    }
614
 
    return jsNull();
615
 
}
616
 
 
617
 
void JSSVGElementInstance::put(ExecState* exec, const Identifier& propertyName, JSValuePtr value, PutPropertySlot& slot)
 
169
bool JSSVGElementInstance::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
170
{
 
171
    return getStaticValueDescriptor<JSSVGElementInstance, Base>(exec, &JSSVGElementInstanceTable, this, propertyName, descriptor);
 
172
}
 
173
 
 
174
JSValue jsSVGElementInstanceCorrespondingElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
175
{
 
176
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
177
    UNUSED_PARAM(exec);
 
178
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
179
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->correspondingElement()));
 
180
}
 
181
 
 
182
JSValue jsSVGElementInstanceCorrespondingUseElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
183
{
 
184
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
185
    UNUSED_PARAM(exec);
 
186
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
187
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->correspondingUseElement()));
 
188
}
 
189
 
 
190
JSValue jsSVGElementInstanceParentNode(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
191
{
 
192
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
193
    UNUSED_PARAM(exec);
 
194
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
195
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->parentNode()));
 
196
}
 
197
 
 
198
JSValue jsSVGElementInstanceChildNodes(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
199
{
 
200
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
201
    UNUSED_PARAM(exec);
 
202
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
203
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->childNodes()));
 
204
}
 
205
 
 
206
JSValue jsSVGElementInstanceFirstChild(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
207
{
 
208
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
209
    UNUSED_PARAM(exec);
 
210
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
211
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->firstChild()));
 
212
}
 
213
 
 
214
JSValue jsSVGElementInstanceLastChild(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
215
{
 
216
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
217
    UNUSED_PARAM(exec);
 
218
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
219
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->lastChild()));
 
220
}
 
221
 
 
222
JSValue jsSVGElementInstancePreviousSibling(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
223
{
 
224
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
225
    UNUSED_PARAM(exec);
 
226
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
227
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->previousSibling()));
 
228
}
 
229
 
 
230
JSValue jsSVGElementInstanceNextSibling(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
231
{
 
232
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
233
    UNUSED_PARAM(exec);
 
234
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
235
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->nextSibling()));
 
236
}
 
237
 
 
238
JSValue jsSVGElementInstanceOnabort(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
239
{
 
240
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
241
    UNUSED_PARAM(exec);
 
242
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
243
    if (EventListener* listener = imp->onabort()) {
 
244
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
245
            return jsFunction;
 
246
    }
 
247
    return jsNull();
 
248
}
 
249
 
 
250
JSValue jsSVGElementInstanceOnblur(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
251
{
 
252
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
253
    UNUSED_PARAM(exec);
 
254
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
255
    if (EventListener* listener = imp->onblur()) {
 
256
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
257
            return jsFunction;
 
258
    }
 
259
    return jsNull();
 
260
}
 
261
 
 
262
JSValue jsSVGElementInstanceOnchange(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
263
{
 
264
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
265
    UNUSED_PARAM(exec);
 
266
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
267
    if (EventListener* listener = imp->onchange()) {
 
268
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
269
            return jsFunction;
 
270
    }
 
271
    return jsNull();
 
272
}
 
273
 
 
274
JSValue jsSVGElementInstanceOnclick(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
275
{
 
276
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
277
    UNUSED_PARAM(exec);
 
278
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
279
    if (EventListener* listener = imp->onclick()) {
 
280
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
281
            return jsFunction;
 
282
    }
 
283
    return jsNull();
 
284
}
 
285
 
 
286
JSValue jsSVGElementInstanceOncontextmenu(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
287
{
 
288
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
289
    UNUSED_PARAM(exec);
 
290
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
291
    if (EventListener* listener = imp->oncontextmenu()) {
 
292
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
293
            return jsFunction;
 
294
    }
 
295
    return jsNull();
 
296
}
 
297
 
 
298
JSValue jsSVGElementInstanceOndblclick(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
299
{
 
300
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
301
    UNUSED_PARAM(exec);
 
302
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
303
    if (EventListener* listener = imp->ondblclick()) {
 
304
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
305
            return jsFunction;
 
306
    }
 
307
    return jsNull();
 
308
}
 
309
 
 
310
JSValue jsSVGElementInstanceOnerror(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
311
{
 
312
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
313
    UNUSED_PARAM(exec);
 
314
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
315
    if (EventListener* listener = imp->onerror()) {
 
316
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
317
            return jsFunction;
 
318
    }
 
319
    return jsNull();
 
320
}
 
321
 
 
322
JSValue jsSVGElementInstanceOnfocus(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
323
{
 
324
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
325
    UNUSED_PARAM(exec);
 
326
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
327
    if (EventListener* listener = imp->onfocus()) {
 
328
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
329
            return jsFunction;
 
330
    }
 
331
    return jsNull();
 
332
}
 
333
 
 
334
JSValue jsSVGElementInstanceOninput(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
335
{
 
336
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
337
    UNUSED_PARAM(exec);
 
338
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
339
    if (EventListener* listener = imp->oninput()) {
 
340
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
341
            return jsFunction;
 
342
    }
 
343
    return jsNull();
 
344
}
 
345
 
 
346
JSValue jsSVGElementInstanceOnkeydown(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
347
{
 
348
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
349
    UNUSED_PARAM(exec);
 
350
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
351
    if (EventListener* listener = imp->onkeydown()) {
 
352
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
353
            return jsFunction;
 
354
    }
 
355
    return jsNull();
 
356
}
 
357
 
 
358
JSValue jsSVGElementInstanceOnkeypress(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
359
{
 
360
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
361
    UNUSED_PARAM(exec);
 
362
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
363
    if (EventListener* listener = imp->onkeypress()) {
 
364
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
365
            return jsFunction;
 
366
    }
 
367
    return jsNull();
 
368
}
 
369
 
 
370
JSValue jsSVGElementInstanceOnkeyup(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
371
{
 
372
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
373
    UNUSED_PARAM(exec);
 
374
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
375
    if (EventListener* listener = imp->onkeyup()) {
 
376
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
377
            return jsFunction;
 
378
    }
 
379
    return jsNull();
 
380
}
 
381
 
 
382
JSValue jsSVGElementInstanceOnload(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
383
{
 
384
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
385
    UNUSED_PARAM(exec);
 
386
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
387
    if (EventListener* listener = imp->onload()) {
 
388
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
389
            return jsFunction;
 
390
    }
 
391
    return jsNull();
 
392
}
 
393
 
 
394
JSValue jsSVGElementInstanceOnmousedown(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
395
{
 
396
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
397
    UNUSED_PARAM(exec);
 
398
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
399
    if (EventListener* listener = imp->onmousedown()) {
 
400
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
401
            return jsFunction;
 
402
    }
 
403
    return jsNull();
 
404
}
 
405
 
 
406
JSValue jsSVGElementInstanceOnmousemove(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
407
{
 
408
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
409
    UNUSED_PARAM(exec);
 
410
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
411
    if (EventListener* listener = imp->onmousemove()) {
 
412
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
413
            return jsFunction;
 
414
    }
 
415
    return jsNull();
 
416
}
 
417
 
 
418
JSValue jsSVGElementInstanceOnmouseout(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
419
{
 
420
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
421
    UNUSED_PARAM(exec);
 
422
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
423
    if (EventListener* listener = imp->onmouseout()) {
 
424
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
425
            return jsFunction;
 
426
    }
 
427
    return jsNull();
 
428
}
 
429
 
 
430
JSValue jsSVGElementInstanceOnmouseover(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
431
{
 
432
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
433
    UNUSED_PARAM(exec);
 
434
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
435
    if (EventListener* listener = imp->onmouseover()) {
 
436
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
437
            return jsFunction;
 
438
    }
 
439
    return jsNull();
 
440
}
 
441
 
 
442
JSValue jsSVGElementInstanceOnmouseup(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
443
{
 
444
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
445
    UNUSED_PARAM(exec);
 
446
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
447
    if (EventListener* listener = imp->onmouseup()) {
 
448
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
449
            return jsFunction;
 
450
    }
 
451
    return jsNull();
 
452
}
 
453
 
 
454
JSValue jsSVGElementInstanceOnmousewheel(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
455
{
 
456
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
457
    UNUSED_PARAM(exec);
 
458
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
459
    if (EventListener* listener = imp->onmousewheel()) {
 
460
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
461
            return jsFunction;
 
462
    }
 
463
    return jsNull();
 
464
}
 
465
 
 
466
JSValue jsSVGElementInstanceOnbeforecut(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
467
{
 
468
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
469
    UNUSED_PARAM(exec);
 
470
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
471
    if (EventListener* listener = imp->onbeforecut()) {
 
472
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
473
            return jsFunction;
 
474
    }
 
475
    return jsNull();
 
476
}
 
477
 
 
478
JSValue jsSVGElementInstanceOncut(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
479
{
 
480
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
481
    UNUSED_PARAM(exec);
 
482
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
483
    if (EventListener* listener = imp->oncut()) {
 
484
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
485
            return jsFunction;
 
486
    }
 
487
    return jsNull();
 
488
}
 
489
 
 
490
JSValue jsSVGElementInstanceOnbeforecopy(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
491
{
 
492
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
493
    UNUSED_PARAM(exec);
 
494
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
495
    if (EventListener* listener = imp->onbeforecopy()) {
 
496
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
497
            return jsFunction;
 
498
    }
 
499
    return jsNull();
 
500
}
 
501
 
 
502
JSValue jsSVGElementInstanceOncopy(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
503
{
 
504
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
505
    UNUSED_PARAM(exec);
 
506
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
507
    if (EventListener* listener = imp->oncopy()) {
 
508
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
509
            return jsFunction;
 
510
    }
 
511
    return jsNull();
 
512
}
 
513
 
 
514
JSValue jsSVGElementInstanceOnbeforepaste(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
515
{
 
516
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
517
    UNUSED_PARAM(exec);
 
518
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
519
    if (EventListener* listener = imp->onbeforepaste()) {
 
520
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
521
            return jsFunction;
 
522
    }
 
523
    return jsNull();
 
524
}
 
525
 
 
526
JSValue jsSVGElementInstanceOnpaste(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
527
{
 
528
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
529
    UNUSED_PARAM(exec);
 
530
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
531
    if (EventListener* listener = imp->onpaste()) {
 
532
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
533
            return jsFunction;
 
534
    }
 
535
    return jsNull();
 
536
}
 
537
 
 
538
JSValue jsSVGElementInstanceOndragenter(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
539
{
 
540
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
541
    UNUSED_PARAM(exec);
 
542
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
543
    if (EventListener* listener = imp->ondragenter()) {
 
544
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
545
            return jsFunction;
 
546
    }
 
547
    return jsNull();
 
548
}
 
549
 
 
550
JSValue jsSVGElementInstanceOndragover(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
551
{
 
552
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
553
    UNUSED_PARAM(exec);
 
554
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
555
    if (EventListener* listener = imp->ondragover()) {
 
556
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
557
            return jsFunction;
 
558
    }
 
559
    return jsNull();
 
560
}
 
561
 
 
562
JSValue jsSVGElementInstanceOndragleave(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
563
{
 
564
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
565
    UNUSED_PARAM(exec);
 
566
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
567
    if (EventListener* listener = imp->ondragleave()) {
 
568
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
569
            return jsFunction;
 
570
    }
 
571
    return jsNull();
 
572
}
 
573
 
 
574
JSValue jsSVGElementInstanceOndrop(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
575
{
 
576
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
577
    UNUSED_PARAM(exec);
 
578
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
579
    if (EventListener* listener = imp->ondrop()) {
 
580
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
581
            return jsFunction;
 
582
    }
 
583
    return jsNull();
 
584
}
 
585
 
 
586
JSValue jsSVGElementInstanceOndragstart(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
587
{
 
588
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
589
    UNUSED_PARAM(exec);
 
590
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
591
    if (EventListener* listener = imp->ondragstart()) {
 
592
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
593
            return jsFunction;
 
594
    }
 
595
    return jsNull();
 
596
}
 
597
 
 
598
JSValue jsSVGElementInstanceOndrag(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
599
{
 
600
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
601
    UNUSED_PARAM(exec);
 
602
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
603
    if (EventListener* listener = imp->ondrag()) {
 
604
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
605
            return jsFunction;
 
606
    }
 
607
    return jsNull();
 
608
}
 
609
 
 
610
JSValue jsSVGElementInstanceOndragend(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
611
{
 
612
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
613
    UNUSED_PARAM(exec);
 
614
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
615
    if (EventListener* listener = imp->ondragend()) {
 
616
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
617
            return jsFunction;
 
618
    }
 
619
    return jsNull();
 
620
}
 
621
 
 
622
JSValue jsSVGElementInstanceOnreset(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
623
{
 
624
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
625
    UNUSED_PARAM(exec);
 
626
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
627
    if (EventListener* listener = imp->onreset()) {
 
628
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
629
            return jsFunction;
 
630
    }
 
631
    return jsNull();
 
632
}
 
633
 
 
634
JSValue jsSVGElementInstanceOnresize(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
635
{
 
636
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
637
    UNUSED_PARAM(exec);
 
638
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
639
    if (EventListener* listener = imp->onresize()) {
 
640
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
641
            return jsFunction;
 
642
    }
 
643
    return jsNull();
 
644
}
 
645
 
 
646
JSValue jsSVGElementInstanceOnscroll(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
647
{
 
648
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
649
    UNUSED_PARAM(exec);
 
650
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
651
    if (EventListener* listener = imp->onscroll()) {
 
652
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
653
            return jsFunction;
 
654
    }
 
655
    return jsNull();
 
656
}
 
657
 
 
658
JSValue jsSVGElementInstanceOnsearch(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
659
{
 
660
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
661
    UNUSED_PARAM(exec);
 
662
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
663
    if (EventListener* listener = imp->onsearch()) {
 
664
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
665
            return jsFunction;
 
666
    }
 
667
    return jsNull();
 
668
}
 
669
 
 
670
JSValue jsSVGElementInstanceOnselect(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
671
{
 
672
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
673
    UNUSED_PARAM(exec);
 
674
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
675
    if (EventListener* listener = imp->onselect()) {
 
676
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
677
            return jsFunction;
 
678
    }
 
679
    return jsNull();
 
680
}
 
681
 
 
682
JSValue jsSVGElementInstanceOnselectstart(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
683
{
 
684
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
685
    UNUSED_PARAM(exec);
 
686
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
687
    if (EventListener* listener = imp->onselectstart()) {
 
688
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
689
            return jsFunction;
 
690
    }
 
691
    return jsNull();
 
692
}
 
693
 
 
694
JSValue jsSVGElementInstanceOnsubmit(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
695
{
 
696
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
697
    UNUSED_PARAM(exec);
 
698
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
699
    if (EventListener* listener = imp->onsubmit()) {
 
700
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
701
            return jsFunction;
 
702
    }
 
703
    return jsNull();
 
704
}
 
705
 
 
706
JSValue jsSVGElementInstanceOnunload(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
707
{
 
708
    JSSVGElementInstance* castedThis = static_cast<JSSVGElementInstance*>(asObject(slot.slotBase()));
 
709
    UNUSED_PARAM(exec);
 
710
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThis->impl());
 
711
    if (EventListener* listener = imp->onunload()) {
 
712
        if (JSObject* jsFunction = listener->jsFunction(imp->scriptExecutionContext()))
 
713
            return jsFunction;
 
714
    }
 
715
    return jsNull();
 
716
}
 
717
 
 
718
void JSSVGElementInstance::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
618
719
{
619
720
    lookupPut<JSSVGElementInstance, Base>(exec, propertyName, value, &JSSVGElementInstanceTable, this, slot);
620
721
}
621
722
 
622
 
void setJSSVGElementInstanceOnabort(ExecState* exec, JSObject* thisObject, JSValuePtr value)
623
 
{
624
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
625
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
626
 
    if (!globalObject)
627
 
        return;
628
 
    imp->setOnabort(globalObject->findOrCreateJSEventListener(exec, value, true));
629
 
}
630
 
 
631
 
void setJSSVGElementInstanceOnblur(ExecState* exec, JSObject* thisObject, JSValuePtr value)
632
 
{
633
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
634
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
635
 
    if (!globalObject)
636
 
        return;
637
 
    imp->setOnblur(globalObject->findOrCreateJSEventListener(exec, value, true));
638
 
}
639
 
 
640
 
void setJSSVGElementInstanceOnchange(ExecState* exec, JSObject* thisObject, JSValuePtr value)
641
 
{
642
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
643
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
644
 
    if (!globalObject)
645
 
        return;
646
 
    imp->setOnchange(globalObject->findOrCreateJSEventListener(exec, value, true));
647
 
}
648
 
 
649
 
void setJSSVGElementInstanceOnclick(ExecState* exec, JSObject* thisObject, JSValuePtr value)
650
 
{
651
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
652
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
653
 
    if (!globalObject)
654
 
        return;
655
 
    imp->setOnclick(globalObject->findOrCreateJSEventListener(exec, value, true));
656
 
}
657
 
 
658
 
void setJSSVGElementInstanceOncontextmenu(ExecState* exec, JSObject* thisObject, JSValuePtr value)
659
 
{
660
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
661
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
662
 
    if (!globalObject)
663
 
        return;
664
 
    imp->setOncontextmenu(globalObject->findOrCreateJSEventListener(exec, value, true));
665
 
}
666
 
 
667
 
void setJSSVGElementInstanceOndblclick(ExecState* exec, JSObject* thisObject, JSValuePtr value)
668
 
{
669
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
670
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
671
 
    if (!globalObject)
672
 
        return;
673
 
    imp->setOndblclick(globalObject->findOrCreateJSEventListener(exec, value, true));
674
 
}
675
 
 
676
 
void setJSSVGElementInstanceOnerror(ExecState* exec, JSObject* thisObject, JSValuePtr value)
677
 
{
678
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
679
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
680
 
    if (!globalObject)
681
 
        return;
682
 
    imp->setOnerror(globalObject->findOrCreateJSEventListener(exec, value, true));
683
 
}
684
 
 
685
 
void setJSSVGElementInstanceOnfocus(ExecState* exec, JSObject* thisObject, JSValuePtr value)
686
 
{
687
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
688
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
689
 
    if (!globalObject)
690
 
        return;
691
 
    imp->setOnfocus(globalObject->findOrCreateJSEventListener(exec, value, true));
692
 
}
693
 
 
694
 
void setJSSVGElementInstanceOninput(ExecState* exec, JSObject* thisObject, JSValuePtr value)
695
 
{
696
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
697
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
698
 
    if (!globalObject)
699
 
        return;
700
 
    imp->setOninput(globalObject->findOrCreateJSEventListener(exec, value, true));
701
 
}
702
 
 
703
 
void setJSSVGElementInstanceOnkeydown(ExecState* exec, JSObject* thisObject, JSValuePtr value)
704
 
{
705
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
706
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
707
 
    if (!globalObject)
708
 
        return;
709
 
    imp->setOnkeydown(globalObject->findOrCreateJSEventListener(exec, value, true));
710
 
}
711
 
 
712
 
void setJSSVGElementInstanceOnkeypress(ExecState* exec, JSObject* thisObject, JSValuePtr value)
713
 
{
714
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
715
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
716
 
    if (!globalObject)
717
 
        return;
718
 
    imp->setOnkeypress(globalObject->findOrCreateJSEventListener(exec, value, true));
719
 
}
720
 
 
721
 
void setJSSVGElementInstanceOnkeyup(ExecState* exec, JSObject* thisObject, JSValuePtr value)
722
 
{
723
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
724
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
725
 
    if (!globalObject)
726
 
        return;
727
 
    imp->setOnkeyup(globalObject->findOrCreateJSEventListener(exec, value, true));
728
 
}
729
 
 
730
 
void setJSSVGElementInstanceOnload(ExecState* exec, JSObject* thisObject, JSValuePtr value)
731
 
{
732
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
733
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
734
 
    if (!globalObject)
735
 
        return;
736
 
    imp->setOnload(globalObject->findOrCreateJSEventListener(exec, value, true));
737
 
}
738
 
 
739
 
void setJSSVGElementInstanceOnmousedown(ExecState* exec, JSObject* thisObject, JSValuePtr value)
740
 
{
741
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
742
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
743
 
    if (!globalObject)
744
 
        return;
745
 
    imp->setOnmousedown(globalObject->findOrCreateJSEventListener(exec, value, true));
746
 
}
747
 
 
748
 
void setJSSVGElementInstanceOnmousemove(ExecState* exec, JSObject* thisObject, JSValuePtr value)
749
 
{
750
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
751
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
752
 
    if (!globalObject)
753
 
        return;
754
 
    imp->setOnmousemove(globalObject->findOrCreateJSEventListener(exec, value, true));
755
 
}
756
 
 
757
 
void setJSSVGElementInstanceOnmouseout(ExecState* exec, JSObject* thisObject, JSValuePtr value)
758
 
{
759
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
760
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
761
 
    if (!globalObject)
762
 
        return;
763
 
    imp->setOnmouseout(globalObject->findOrCreateJSEventListener(exec, value, true));
764
 
}
765
 
 
766
 
void setJSSVGElementInstanceOnmouseover(ExecState* exec, JSObject* thisObject, JSValuePtr value)
767
 
{
768
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
769
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
770
 
    if (!globalObject)
771
 
        return;
772
 
    imp->setOnmouseover(globalObject->findOrCreateJSEventListener(exec, value, true));
773
 
}
774
 
 
775
 
void setJSSVGElementInstanceOnmouseup(ExecState* exec, JSObject* thisObject, JSValuePtr value)
776
 
{
777
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
778
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
779
 
    if (!globalObject)
780
 
        return;
781
 
    imp->setOnmouseup(globalObject->findOrCreateJSEventListener(exec, value, true));
782
 
}
783
 
 
784
 
void setJSSVGElementInstanceOnmousewheel(ExecState* exec, JSObject* thisObject, JSValuePtr value)
785
 
{
786
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
787
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
788
 
    if (!globalObject)
789
 
        return;
790
 
    imp->setOnmousewheel(globalObject->findOrCreateJSEventListener(exec, value, true));
791
 
}
792
 
 
793
 
void setJSSVGElementInstanceOnbeforecut(ExecState* exec, JSObject* thisObject, JSValuePtr value)
794
 
{
795
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
796
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
797
 
    if (!globalObject)
798
 
        return;
799
 
    imp->setOnbeforecut(globalObject->findOrCreateJSEventListener(exec, value, true));
800
 
}
801
 
 
802
 
void setJSSVGElementInstanceOncut(ExecState* exec, JSObject* thisObject, JSValuePtr value)
803
 
{
804
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
805
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
806
 
    if (!globalObject)
807
 
        return;
808
 
    imp->setOncut(globalObject->findOrCreateJSEventListener(exec, value, true));
809
 
}
810
 
 
811
 
void setJSSVGElementInstanceOnbeforecopy(ExecState* exec, JSObject* thisObject, JSValuePtr value)
812
 
{
813
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
814
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
815
 
    if (!globalObject)
816
 
        return;
817
 
    imp->setOnbeforecopy(globalObject->findOrCreateJSEventListener(exec, value, true));
818
 
}
819
 
 
820
 
void setJSSVGElementInstanceOncopy(ExecState* exec, JSObject* thisObject, JSValuePtr value)
821
 
{
822
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
823
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
824
 
    if (!globalObject)
825
 
        return;
826
 
    imp->setOncopy(globalObject->findOrCreateJSEventListener(exec, value, true));
827
 
}
828
 
 
829
 
void setJSSVGElementInstanceOnbeforepaste(ExecState* exec, JSObject* thisObject, JSValuePtr value)
830
 
{
831
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
832
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
833
 
    if (!globalObject)
834
 
        return;
835
 
    imp->setOnbeforepaste(globalObject->findOrCreateJSEventListener(exec, value, true));
836
 
}
837
 
 
838
 
void setJSSVGElementInstanceOnpaste(ExecState* exec, JSObject* thisObject, JSValuePtr value)
839
 
{
840
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
841
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
842
 
    if (!globalObject)
843
 
        return;
844
 
    imp->setOnpaste(globalObject->findOrCreateJSEventListener(exec, value, true));
845
 
}
846
 
 
847
 
void setJSSVGElementInstanceOndragenter(ExecState* exec, JSObject* thisObject, JSValuePtr value)
848
 
{
849
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
850
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
851
 
    if (!globalObject)
852
 
        return;
853
 
    imp->setOndragenter(globalObject->findOrCreateJSEventListener(exec, value, true));
854
 
}
855
 
 
856
 
void setJSSVGElementInstanceOndragover(ExecState* exec, JSObject* thisObject, JSValuePtr value)
857
 
{
858
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
859
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
860
 
    if (!globalObject)
861
 
        return;
862
 
    imp->setOndragover(globalObject->findOrCreateJSEventListener(exec, value, true));
863
 
}
864
 
 
865
 
void setJSSVGElementInstanceOndragleave(ExecState* exec, JSObject* thisObject, JSValuePtr value)
866
 
{
867
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
868
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
869
 
    if (!globalObject)
870
 
        return;
871
 
    imp->setOndragleave(globalObject->findOrCreateJSEventListener(exec, value, true));
872
 
}
873
 
 
874
 
void setJSSVGElementInstanceOndrop(ExecState* exec, JSObject* thisObject, JSValuePtr value)
875
 
{
876
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
877
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
878
 
    if (!globalObject)
879
 
        return;
880
 
    imp->setOndrop(globalObject->findOrCreateJSEventListener(exec, value, true));
881
 
}
882
 
 
883
 
void setJSSVGElementInstanceOndragstart(ExecState* exec, JSObject* thisObject, JSValuePtr value)
884
 
{
885
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
886
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
887
 
    if (!globalObject)
888
 
        return;
889
 
    imp->setOndragstart(globalObject->findOrCreateJSEventListener(exec, value, true));
890
 
}
891
 
 
892
 
void setJSSVGElementInstanceOndrag(ExecState* exec, JSObject* thisObject, JSValuePtr value)
893
 
{
894
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
895
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
896
 
    if (!globalObject)
897
 
        return;
898
 
    imp->setOndrag(globalObject->findOrCreateJSEventListener(exec, value, true));
899
 
}
900
 
 
901
 
void setJSSVGElementInstanceOndragend(ExecState* exec, JSObject* thisObject, JSValuePtr value)
902
 
{
903
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
904
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
905
 
    if (!globalObject)
906
 
        return;
907
 
    imp->setOndragend(globalObject->findOrCreateJSEventListener(exec, value, true));
908
 
}
909
 
 
910
 
void setJSSVGElementInstanceOnreset(ExecState* exec, JSObject* thisObject, JSValuePtr value)
911
 
{
912
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
913
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
914
 
    if (!globalObject)
915
 
        return;
916
 
    imp->setOnreset(globalObject->findOrCreateJSEventListener(exec, value, true));
917
 
}
918
 
 
919
 
void setJSSVGElementInstanceOnresize(ExecState* exec, JSObject* thisObject, JSValuePtr value)
920
 
{
921
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
922
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
923
 
    if (!globalObject)
924
 
        return;
925
 
    imp->setOnresize(globalObject->findOrCreateJSEventListener(exec, value, true));
926
 
}
927
 
 
928
 
void setJSSVGElementInstanceOnscroll(ExecState* exec, JSObject* thisObject, JSValuePtr value)
929
 
{
930
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
931
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
932
 
    if (!globalObject)
933
 
        return;
934
 
    imp->setOnscroll(globalObject->findOrCreateJSEventListener(exec, value, true));
935
 
}
936
 
 
937
 
void setJSSVGElementInstanceOnsearch(ExecState* exec, JSObject* thisObject, JSValuePtr value)
938
 
{
939
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
940
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
941
 
    if (!globalObject)
942
 
        return;
943
 
    imp->setOnsearch(globalObject->findOrCreateJSEventListener(exec, value, true));
944
 
}
945
 
 
946
 
void setJSSVGElementInstanceOnselect(ExecState* exec, JSObject* thisObject, JSValuePtr value)
947
 
{
948
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
949
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
950
 
    if (!globalObject)
951
 
        return;
952
 
    imp->setOnselect(globalObject->findOrCreateJSEventListener(exec, value, true));
953
 
}
954
 
 
955
 
void setJSSVGElementInstanceOnselectstart(ExecState* exec, JSObject* thisObject, JSValuePtr value)
956
 
{
957
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
958
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
959
 
    if (!globalObject)
960
 
        return;
961
 
    imp->setOnselectstart(globalObject->findOrCreateJSEventListener(exec, value, true));
962
 
}
963
 
 
964
 
void setJSSVGElementInstanceOnsubmit(ExecState* exec, JSObject* thisObject, JSValuePtr value)
965
 
{
966
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
967
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
968
 
    if (!globalObject)
969
 
        return;
970
 
    imp->setOnsubmit(globalObject->findOrCreateJSEventListener(exec, value, true));
971
 
}
972
 
 
973
 
void setJSSVGElementInstanceOnunload(ExecState* exec, JSObject* thisObject, JSValuePtr value)
974
 
{
975
 
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
976
 
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
977
 
    if (!globalObject)
978
 
        return;
979
 
    imp->setOnunload(globalObject->findOrCreateJSEventListener(exec, value, true));
980
 
}
981
 
 
982
 
JSValuePtr jsSVGElementInstancePrototypeFunctionAddEventListener(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
983
 
{
984
 
    if (!thisValue->isObject(&JSSVGElementInstance::s_info))
 
723
void setJSSVGElementInstanceOnabort(ExecState* exec, JSObject* thisObject, JSValue value)
 
724
{
 
725
    UNUSED_PARAM(exec);
 
726
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
727
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
728
    if (!globalObject)
 
729
        return;
 
730
    imp->setOnabort(globalObject->createJSAttributeEventListener(value));
 
731
}
 
732
 
 
733
void setJSSVGElementInstanceOnblur(ExecState* exec, JSObject* thisObject, JSValue value)
 
734
{
 
735
    UNUSED_PARAM(exec);
 
736
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
737
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
738
    if (!globalObject)
 
739
        return;
 
740
    imp->setOnblur(globalObject->createJSAttributeEventListener(value));
 
741
}
 
742
 
 
743
void setJSSVGElementInstanceOnchange(ExecState* exec, JSObject* thisObject, JSValue value)
 
744
{
 
745
    UNUSED_PARAM(exec);
 
746
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
747
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
748
    if (!globalObject)
 
749
        return;
 
750
    imp->setOnchange(globalObject->createJSAttributeEventListener(value));
 
751
}
 
752
 
 
753
void setJSSVGElementInstanceOnclick(ExecState* exec, JSObject* thisObject, JSValue value)
 
754
{
 
755
    UNUSED_PARAM(exec);
 
756
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
757
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
758
    if (!globalObject)
 
759
        return;
 
760
    imp->setOnclick(globalObject->createJSAttributeEventListener(value));
 
761
}
 
762
 
 
763
void setJSSVGElementInstanceOncontextmenu(ExecState* exec, JSObject* thisObject, JSValue value)
 
764
{
 
765
    UNUSED_PARAM(exec);
 
766
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
767
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
768
    if (!globalObject)
 
769
        return;
 
770
    imp->setOncontextmenu(globalObject->createJSAttributeEventListener(value));
 
771
}
 
772
 
 
773
void setJSSVGElementInstanceOndblclick(ExecState* exec, JSObject* thisObject, JSValue value)
 
774
{
 
775
    UNUSED_PARAM(exec);
 
776
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
777
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
778
    if (!globalObject)
 
779
        return;
 
780
    imp->setOndblclick(globalObject->createJSAttributeEventListener(value));
 
781
}
 
782
 
 
783
void setJSSVGElementInstanceOnerror(ExecState* exec, JSObject* thisObject, JSValue value)
 
784
{
 
785
    UNUSED_PARAM(exec);
 
786
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
787
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
788
    if (!globalObject)
 
789
        return;
 
790
    imp->setOnerror(globalObject->createJSAttributeEventListener(value));
 
791
}
 
792
 
 
793
void setJSSVGElementInstanceOnfocus(ExecState* exec, JSObject* thisObject, JSValue value)
 
794
{
 
795
    UNUSED_PARAM(exec);
 
796
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
797
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
798
    if (!globalObject)
 
799
        return;
 
800
    imp->setOnfocus(globalObject->createJSAttributeEventListener(value));
 
801
}
 
802
 
 
803
void setJSSVGElementInstanceOninput(ExecState* exec, JSObject* thisObject, JSValue value)
 
804
{
 
805
    UNUSED_PARAM(exec);
 
806
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
807
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
808
    if (!globalObject)
 
809
        return;
 
810
    imp->setOninput(globalObject->createJSAttributeEventListener(value));
 
811
}
 
812
 
 
813
void setJSSVGElementInstanceOnkeydown(ExecState* exec, JSObject* thisObject, JSValue value)
 
814
{
 
815
    UNUSED_PARAM(exec);
 
816
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
817
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
818
    if (!globalObject)
 
819
        return;
 
820
    imp->setOnkeydown(globalObject->createJSAttributeEventListener(value));
 
821
}
 
822
 
 
823
void setJSSVGElementInstanceOnkeypress(ExecState* exec, JSObject* thisObject, JSValue value)
 
824
{
 
825
    UNUSED_PARAM(exec);
 
826
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
827
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
828
    if (!globalObject)
 
829
        return;
 
830
    imp->setOnkeypress(globalObject->createJSAttributeEventListener(value));
 
831
}
 
832
 
 
833
void setJSSVGElementInstanceOnkeyup(ExecState* exec, JSObject* thisObject, JSValue value)
 
834
{
 
835
    UNUSED_PARAM(exec);
 
836
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
837
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
838
    if (!globalObject)
 
839
        return;
 
840
    imp->setOnkeyup(globalObject->createJSAttributeEventListener(value));
 
841
}
 
842
 
 
843
void setJSSVGElementInstanceOnload(ExecState* exec, JSObject* thisObject, JSValue value)
 
844
{
 
845
    UNUSED_PARAM(exec);
 
846
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
847
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
848
    if (!globalObject)
 
849
        return;
 
850
    imp->setOnload(globalObject->createJSAttributeEventListener(value));
 
851
}
 
852
 
 
853
void setJSSVGElementInstanceOnmousedown(ExecState* exec, JSObject* thisObject, JSValue value)
 
854
{
 
855
    UNUSED_PARAM(exec);
 
856
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
857
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
858
    if (!globalObject)
 
859
        return;
 
860
    imp->setOnmousedown(globalObject->createJSAttributeEventListener(value));
 
861
}
 
862
 
 
863
void setJSSVGElementInstanceOnmousemove(ExecState* exec, JSObject* thisObject, JSValue value)
 
864
{
 
865
    UNUSED_PARAM(exec);
 
866
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
867
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
868
    if (!globalObject)
 
869
        return;
 
870
    imp->setOnmousemove(globalObject->createJSAttributeEventListener(value));
 
871
}
 
872
 
 
873
void setJSSVGElementInstanceOnmouseout(ExecState* exec, JSObject* thisObject, JSValue value)
 
874
{
 
875
    UNUSED_PARAM(exec);
 
876
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
877
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
878
    if (!globalObject)
 
879
        return;
 
880
    imp->setOnmouseout(globalObject->createJSAttributeEventListener(value));
 
881
}
 
882
 
 
883
void setJSSVGElementInstanceOnmouseover(ExecState* exec, JSObject* thisObject, JSValue value)
 
884
{
 
885
    UNUSED_PARAM(exec);
 
886
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
887
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
888
    if (!globalObject)
 
889
        return;
 
890
    imp->setOnmouseover(globalObject->createJSAttributeEventListener(value));
 
891
}
 
892
 
 
893
void setJSSVGElementInstanceOnmouseup(ExecState* exec, JSObject* thisObject, JSValue value)
 
894
{
 
895
    UNUSED_PARAM(exec);
 
896
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
897
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
898
    if (!globalObject)
 
899
        return;
 
900
    imp->setOnmouseup(globalObject->createJSAttributeEventListener(value));
 
901
}
 
902
 
 
903
void setJSSVGElementInstanceOnmousewheel(ExecState* exec, JSObject* thisObject, JSValue value)
 
904
{
 
905
    UNUSED_PARAM(exec);
 
906
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
907
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
908
    if (!globalObject)
 
909
        return;
 
910
    imp->setOnmousewheel(globalObject->createJSAttributeEventListener(value));
 
911
}
 
912
 
 
913
void setJSSVGElementInstanceOnbeforecut(ExecState* exec, JSObject* thisObject, JSValue value)
 
914
{
 
915
    UNUSED_PARAM(exec);
 
916
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
917
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
918
    if (!globalObject)
 
919
        return;
 
920
    imp->setOnbeforecut(globalObject->createJSAttributeEventListener(value));
 
921
}
 
922
 
 
923
void setJSSVGElementInstanceOncut(ExecState* exec, JSObject* thisObject, JSValue value)
 
924
{
 
925
    UNUSED_PARAM(exec);
 
926
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
927
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
928
    if (!globalObject)
 
929
        return;
 
930
    imp->setOncut(globalObject->createJSAttributeEventListener(value));
 
931
}
 
932
 
 
933
void setJSSVGElementInstanceOnbeforecopy(ExecState* exec, JSObject* thisObject, JSValue value)
 
934
{
 
935
    UNUSED_PARAM(exec);
 
936
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
937
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
938
    if (!globalObject)
 
939
        return;
 
940
    imp->setOnbeforecopy(globalObject->createJSAttributeEventListener(value));
 
941
}
 
942
 
 
943
void setJSSVGElementInstanceOncopy(ExecState* exec, JSObject* thisObject, JSValue value)
 
944
{
 
945
    UNUSED_PARAM(exec);
 
946
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
947
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
948
    if (!globalObject)
 
949
        return;
 
950
    imp->setOncopy(globalObject->createJSAttributeEventListener(value));
 
951
}
 
952
 
 
953
void setJSSVGElementInstanceOnbeforepaste(ExecState* exec, JSObject* thisObject, JSValue value)
 
954
{
 
955
    UNUSED_PARAM(exec);
 
956
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
957
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
958
    if (!globalObject)
 
959
        return;
 
960
    imp->setOnbeforepaste(globalObject->createJSAttributeEventListener(value));
 
961
}
 
962
 
 
963
void setJSSVGElementInstanceOnpaste(ExecState* exec, JSObject* thisObject, JSValue value)
 
964
{
 
965
    UNUSED_PARAM(exec);
 
966
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
967
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
968
    if (!globalObject)
 
969
        return;
 
970
    imp->setOnpaste(globalObject->createJSAttributeEventListener(value));
 
971
}
 
972
 
 
973
void setJSSVGElementInstanceOndragenter(ExecState* exec, JSObject* thisObject, JSValue value)
 
974
{
 
975
    UNUSED_PARAM(exec);
 
976
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
977
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
978
    if (!globalObject)
 
979
        return;
 
980
    imp->setOndragenter(globalObject->createJSAttributeEventListener(value));
 
981
}
 
982
 
 
983
void setJSSVGElementInstanceOndragover(ExecState* exec, JSObject* thisObject, JSValue value)
 
984
{
 
985
    UNUSED_PARAM(exec);
 
986
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
987
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
988
    if (!globalObject)
 
989
        return;
 
990
    imp->setOndragover(globalObject->createJSAttributeEventListener(value));
 
991
}
 
992
 
 
993
void setJSSVGElementInstanceOndragleave(ExecState* exec, JSObject* thisObject, JSValue value)
 
994
{
 
995
    UNUSED_PARAM(exec);
 
996
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
997
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
998
    if (!globalObject)
 
999
        return;
 
1000
    imp->setOndragleave(globalObject->createJSAttributeEventListener(value));
 
1001
}
 
1002
 
 
1003
void setJSSVGElementInstanceOndrop(ExecState* exec, JSObject* thisObject, JSValue value)
 
1004
{
 
1005
    UNUSED_PARAM(exec);
 
1006
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1007
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1008
    if (!globalObject)
 
1009
        return;
 
1010
    imp->setOndrop(globalObject->createJSAttributeEventListener(value));
 
1011
}
 
1012
 
 
1013
void setJSSVGElementInstanceOndragstart(ExecState* exec, JSObject* thisObject, JSValue value)
 
1014
{
 
1015
    UNUSED_PARAM(exec);
 
1016
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1017
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1018
    if (!globalObject)
 
1019
        return;
 
1020
    imp->setOndragstart(globalObject->createJSAttributeEventListener(value));
 
1021
}
 
1022
 
 
1023
void setJSSVGElementInstanceOndrag(ExecState* exec, JSObject* thisObject, JSValue value)
 
1024
{
 
1025
    UNUSED_PARAM(exec);
 
1026
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1027
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1028
    if (!globalObject)
 
1029
        return;
 
1030
    imp->setOndrag(globalObject->createJSAttributeEventListener(value));
 
1031
}
 
1032
 
 
1033
void setJSSVGElementInstanceOndragend(ExecState* exec, JSObject* thisObject, JSValue value)
 
1034
{
 
1035
    UNUSED_PARAM(exec);
 
1036
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1037
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1038
    if (!globalObject)
 
1039
        return;
 
1040
    imp->setOndragend(globalObject->createJSAttributeEventListener(value));
 
1041
}
 
1042
 
 
1043
void setJSSVGElementInstanceOnreset(ExecState* exec, JSObject* thisObject, JSValue value)
 
1044
{
 
1045
    UNUSED_PARAM(exec);
 
1046
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1047
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1048
    if (!globalObject)
 
1049
        return;
 
1050
    imp->setOnreset(globalObject->createJSAttributeEventListener(value));
 
1051
}
 
1052
 
 
1053
void setJSSVGElementInstanceOnresize(ExecState* exec, JSObject* thisObject, JSValue value)
 
1054
{
 
1055
    UNUSED_PARAM(exec);
 
1056
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1057
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1058
    if (!globalObject)
 
1059
        return;
 
1060
    imp->setOnresize(globalObject->createJSAttributeEventListener(value));
 
1061
}
 
1062
 
 
1063
void setJSSVGElementInstanceOnscroll(ExecState* exec, JSObject* thisObject, JSValue value)
 
1064
{
 
1065
    UNUSED_PARAM(exec);
 
1066
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1067
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1068
    if (!globalObject)
 
1069
        return;
 
1070
    imp->setOnscroll(globalObject->createJSAttributeEventListener(value));
 
1071
}
 
1072
 
 
1073
void setJSSVGElementInstanceOnsearch(ExecState* exec, JSObject* thisObject, JSValue value)
 
1074
{
 
1075
    UNUSED_PARAM(exec);
 
1076
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1077
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1078
    if (!globalObject)
 
1079
        return;
 
1080
    imp->setOnsearch(globalObject->createJSAttributeEventListener(value));
 
1081
}
 
1082
 
 
1083
void setJSSVGElementInstanceOnselect(ExecState* exec, JSObject* thisObject, JSValue value)
 
1084
{
 
1085
    UNUSED_PARAM(exec);
 
1086
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1087
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1088
    if (!globalObject)
 
1089
        return;
 
1090
    imp->setOnselect(globalObject->createJSAttributeEventListener(value));
 
1091
}
 
1092
 
 
1093
void setJSSVGElementInstanceOnselectstart(ExecState* exec, JSObject* thisObject, JSValue value)
 
1094
{
 
1095
    UNUSED_PARAM(exec);
 
1096
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1097
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1098
    if (!globalObject)
 
1099
        return;
 
1100
    imp->setOnselectstart(globalObject->createJSAttributeEventListener(value));
 
1101
}
 
1102
 
 
1103
void setJSSVGElementInstanceOnsubmit(ExecState* exec, JSObject* thisObject, JSValue value)
 
1104
{
 
1105
    UNUSED_PARAM(exec);
 
1106
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1107
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1108
    if (!globalObject)
 
1109
        return;
 
1110
    imp->setOnsubmit(globalObject->createJSAttributeEventListener(value));
 
1111
}
 
1112
 
 
1113
void setJSSVGElementInstanceOnunload(ExecState* exec, JSObject* thisObject, JSValue value)
 
1114
{
 
1115
    UNUSED_PARAM(exec);
 
1116
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(static_cast<JSSVGElementInstance*>(thisObject)->impl());
 
1117
    JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(imp->scriptExecutionContext());
 
1118
    if (!globalObject)
 
1119
        return;
 
1120
    imp->setOnunload(globalObject->createJSAttributeEventListener(value));
 
1121
}
 
1122
 
 
1123
JSValue JSC_HOST_CALL jsSVGElementInstancePrototypeFunctionAddEventListener(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
 
1124
{
 
1125
    UNUSED_PARAM(args);
 
1126
    if (!thisValue.inherits(&JSSVGElementInstance::s_info))
985
1127
        return throwError(exec, TypeError);
986
1128
    JSSVGElementInstance* castedThisObj = static_cast<JSSVGElementInstance*>(asObject(thisValue));
987
1129
    return castedThisObj->addEventListener(exec, args);
988
1130
}
989
1131
 
990
 
JSValuePtr jsSVGElementInstancePrototypeFunctionRemoveEventListener(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
 
1132
JSValue JSC_HOST_CALL jsSVGElementInstancePrototypeFunctionRemoveEventListener(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
991
1133
{
992
 
    if (!thisValue->isObject(&JSSVGElementInstance::s_info))
 
1134
    UNUSED_PARAM(args);
 
1135
    if (!thisValue.inherits(&JSSVGElementInstance::s_info))
993
1136
        return throwError(exec, TypeError);
994
1137
    JSSVGElementInstance* castedThisObj = static_cast<JSSVGElementInstance*>(asObject(thisValue));
995
1138
    return castedThisObj->removeEventListener(exec, args);
996
1139
}
997
1140
 
998
 
JSValuePtr jsSVGElementInstancePrototypeFunctionDispatchEvent(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
 
1141
JSValue JSC_HOST_CALL jsSVGElementInstancePrototypeFunctionDispatchEvent(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
999
1142
{
1000
 
    if (!thisValue->isObject(&JSSVGElementInstance::s_info))
 
1143
    UNUSED_PARAM(args);
 
1144
    if (!thisValue.inherits(&JSSVGElementInstance::s_info))
1001
1145
        return throwError(exec, TypeError);
1002
1146
    JSSVGElementInstance* castedThisObj = static_cast<JSSVGElementInstance*>(asObject(thisValue));
1003
1147
    SVGElementInstance* imp = static_cast<SVGElementInstance*>(castedThisObj->impl());
1004
1148
    ExceptionCode ec = 0;
1005
 
    Event* event = toEvent(args.at(exec, 0));
1006
 
 
1007
 
 
1008
 
    JSC::JSValuePtr result = jsBoolean(imp->dispatchEvent(event, ec));
 
1149
    Event* event = toEvent(args.at(0));
 
1150
 
 
1151
 
 
1152
    JSC::JSValue result = jsBoolean(imp->dispatchEvent(event, ec));
1009
1153
    setDOMException(exec, ec);
1010
1154
    return result;
1011
1155
}
1012
1156
 
1013
 
JSC::JSValuePtr toJS(JSC::ExecState* exec, SVGElementInstance* object)
1014
 
{
1015
 
    return getDOMObjectWrapper<JSSVGElementInstance>(exec, object);
1016
 
}
1017
 
SVGElementInstance* toSVGElementInstance(JSC::JSValuePtr value)
1018
 
{
1019
 
    return value->isObject(&JSSVGElementInstance::s_info) ? static_cast<JSSVGElementInstance*>(asObject(value))->impl() : 0;
 
1157
SVGElementInstance* toSVGElementInstance(JSC::JSValue value)
 
1158
{
 
1159
    return value.inherits(&JSSVGElementInstance::s_info) ? static_cast<JSSVGElementInstance*>(asObject(value))->impl() : 0;
1020
1160
}
1021
1161
 
1022
1162
}