← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm
 
1
/*
 
2
 * This file is part of the WebKit open source project.
 
3
 * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 * 2. Redistributions in binary form must reproduce the above copyright
 
11
 *    notice, this list of conditions and the following disclaimer in the
 
12
 *    documentation and/or other materials provided with the distribution.
 
13
 *
 
14
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 
15
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
16
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
17
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 
18
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
19
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
20
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
21
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
22
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
23
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
24
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
25
 */
 
26
 
 
27
#import "config.h"
 
28
#import "DOMInternal.h"
 
29
 
 
30
#import "DOMTestObj.h"
 
31
 
 
32
#import "DOMBlobInternal.h"
 
33
#import "DOMCSSRuleInternal.h"
 
34
#import "DOMCSSValueInternal.h"
 
35
#import "DOMDictionaryInternal.h"
 
36
#import "DOMDocumentInternal.h"
 
37
#import "DOMEventInternal.h"
 
38
#import "DOMIDBKeyInternal.h"
 
39
#import "DOMNodeInternal.h"
 
40
#import "DOMSVGDocumentInternal.h"
 
41
#import "DOMSVGPointInternal.h"
 
42
#import "DOMStyleSheetInternal.h"
 
43
#import "DOMTestObjInternal.h"
 
44
#import "DOMTestObjectAConstructorInternal.h"
 
45
#import "DOMTestObjectBConstructorInternal.h"
 
46
#import "DOMTestObjectCConstructorInternal.h"
 
47
#import "DOMaInternal.h"
 
48
#import "DOManyInternal.h"
 
49
#import "DOMbInternal.h"
 
50
#import "DOMboolInternal.h"
 
51
#import "DOMdInternal.h"
 
52
#import "DOMeInternal.h"
 
53
#import "Dictionary.h"
 
54
#import "Document.h"
 
55
#import "EventListener.h"
 
56
#import "ExceptionHandlers.h"
 
57
#import "HTMLNames.h"
 
58
#import "IDBKey.h"
 
59
#import "JSMainThreadExecState.h"
 
60
#import "KURL.h"
 
61
#import "Node.h"
 
62
#import "ObjCEventListener.h"
 
63
#import "SVGDocument.h"
 
64
#import "SVGStaticPropertyTearOff.h"
 
65
#import "SerializedScriptValue.h"
 
66
#import "TestObj.h"
 
67
#import "TestObjectAConstructor.h"
 
68
#import "TestObjectBConstructor.h"
 
69
#import "TestObjectCConstructor.h"
 
70
#import "ThreadCheck.h"
 
71
#import "WebCoreObjCExtras.h"
 
72
#import "WebScriptObjectPrivate.h"
 
73
#import "a.h"
 
74
#import "any.h"
 
75
#import "b.h"
 
76
#import "bool.h"
 
77
#import "d.h"
 
78
#import "e.h"
 
79
#import <wtf/GetPtr.h>
 
80
 
 
81
#define IMPL reinterpret_cast<WebCore::TestObj*>(_internal)
 
82
 
 
83
@implementation DOMTestObj
 
84
 
 
85
- (void)dealloc
 
86
{
 
87
    if (WebCoreObjCScheduleDeallocateOnMainThread([DOMTestObj class], self))
 
88
        return;
 
89
 
 
90
    if (_internal)
 
91
        IMPL->deref();
 
92
    [super dealloc];
 
93
}
 
94
 
 
95
- (void)finalize
 
96
{
 
97
    if (_internal)
 
98
        IMPL->deref();
 
99
    [super finalize];
 
100
}
 
101
 
 
102
- (int)readOnlyLongAttr
 
103
{
 
104
    WebCore::JSMainThreadNullState state;
 
105
    return IMPL->readOnlyLongAttr();
 
106
}
 
107
 
 
108
- (NSString *)readOnlyStringAttr
 
109
{
 
110
    WebCore::JSMainThreadNullState state;
 
111
    return IMPL->readOnlyStringAttr();
 
112
}
 
113
 
 
114
- (DOMTestObj *)readOnlyTestObjAttr
 
115
{
 
116
    WebCore::JSMainThreadNullState state;
 
117
    return kit(WTF::getPtr(IMPL->readOnlyTestObjAttr()));
 
118
}
 
119
 
 
120
- (short)shortAttr
 
121
{
 
122
    WebCore::JSMainThreadNullState state;
 
123
    return IMPL->shortAttr();
 
124
}
 
125
 
 
126
- (void)setShortAttr:(short)newShortAttr
 
127
{
 
128
    WebCore::JSMainThreadNullState state;
 
129
    IMPL->setShortAttr(newShortAttr);
 
130
}
 
131
 
 
132
- (unsigned short)unsignedShortAttr
 
133
{
 
134
    WebCore::JSMainThreadNullState state;
 
135
    return IMPL->unsignedShortAttr();
 
136
}
 
137
 
 
138
- (void)setUnsignedShortAttr:(unsigned short)newUnsignedShortAttr
 
139
{
 
140
    WebCore::JSMainThreadNullState state;
 
141
    IMPL->setUnsignedShortAttr(newUnsignedShortAttr);
 
142
}
 
143
 
 
144
- (int)longAttr
 
145
{
 
146
    WebCore::JSMainThreadNullState state;
 
147
    return IMPL->longAttr();
 
148
}
 
149
 
 
150
- (void)setLongAttr:(int)newLongAttr
 
151
{
 
152
    WebCore::JSMainThreadNullState state;
 
153
    IMPL->setLongAttr(newLongAttr);
 
154
}
 
155
 
 
156
- (long long)longLongAttr
 
157
{
 
158
    WebCore::JSMainThreadNullState state;
 
159
    return IMPL->longLongAttr();
 
160
}
 
161
 
 
162
- (void)setLongLongAttr:(long long)newLongLongAttr
 
163
{
 
164
    WebCore::JSMainThreadNullState state;
 
165
    IMPL->setLongLongAttr(newLongLongAttr);
 
166
}
 
167
 
 
168
- (unsigned long long)unsignedLongLongAttr
 
169
{
 
170
    WebCore::JSMainThreadNullState state;
 
171
    return IMPL->unsignedLongLongAttr();
 
172
}
 
173
 
 
174
- (void)setUnsignedLongLongAttr:(unsigned long long)newUnsignedLongLongAttr
 
175
{
 
176
    WebCore::JSMainThreadNullState state;
 
177
    IMPL->setUnsignedLongLongAttr(newUnsignedLongLongAttr);
 
178
}
 
179
 
 
180
- (NSString *)stringAttr
 
181
{
 
182
    WebCore::JSMainThreadNullState state;
 
183
    return IMPL->stringAttr();
 
184
}
 
185
 
 
186
- (void)setStringAttr:(NSString *)newStringAttr
 
187
{
 
188
    WebCore::JSMainThreadNullState state;
 
189
    IMPL->setStringAttr(newStringAttr);
 
190
}
 
191
 
 
192
- (DOMTestObj *)testObjAttr
 
193
{
 
194
    WebCore::JSMainThreadNullState state;
 
195
    return kit(WTF::getPtr(IMPL->testObjAttr()));
 
196
}
 
197
 
 
198
- (void)setTestObjAttr:(DOMTestObj *)newTestObjAttr
 
199
{
 
200
    WebCore::JSMainThreadNullState state;
 
201
    ASSERT(newTestObjAttr);
 
202
 
 
203
    IMPL->setTestObjAttr(core(newTestObjAttr));
 
204
}
 
205
 
 
206
- (DOMTestObj *)XMLObjAttr
 
207
{
 
208
    WebCore::JSMainThreadNullState state;
 
209
    return kit(WTF::getPtr(IMPL->xmlObjAttr()));
 
210
}
 
211
 
 
212
- (void)setXMLObjAttr:(DOMTestObj *)newXMLObjAttr
 
213
{
 
214
    WebCore::JSMainThreadNullState state;
 
215
    ASSERT(newXMLObjAttr);
 
216
 
 
217
    IMPL->setXMLObjAttr(core(newXMLObjAttr));
 
218
}
 
219
 
 
220
- (BOOL)create
 
221
{
 
222
    WebCore::JSMainThreadNullState state;
 
223
    return IMPL->isCreate();
 
224
}
 
225
 
 
226
- (void)setCreate:(BOOL)newCreate
 
227
{
 
228
    WebCore::JSMainThreadNullState state;
 
229
    IMPL->setCreate(newCreate);
 
230
}
 
231
 
 
232
- (NSString *)reflectedStringAttr
 
233
{
 
234
    WebCore::JSMainThreadNullState state;
 
235
    return IMPL->getAttribute(WebCore::HTMLNames::reflectedstringattrAttr);
 
236
}
 
237
 
 
238
- (void)setReflectedStringAttr:(NSString *)newReflectedStringAttr
 
239
{
 
240
    WebCore::JSMainThreadNullState state;
 
241
    IMPL->setAttribute(WebCore::HTMLNames::reflectedstringattrAttr, newReflectedStringAttr);
 
242
}
 
243
 
 
244
- (int)reflectedIntegralAttr
 
245
{
 
246
    WebCore::JSMainThreadNullState state;
 
247
    return IMPL->getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr);
 
248
}
 
249
 
 
250
- (void)setReflectedIntegralAttr:(int)newReflectedIntegralAttr
 
251
{
 
252
    WebCore::JSMainThreadNullState state;
 
253
    IMPL->setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, newReflectedIntegralAttr);
 
254
}
 
255
 
 
256
- (unsigned)reflectedUnsignedIntegralAttr
 
257
{
 
258
    WebCore::JSMainThreadNullState state;
 
259
    return IMPL->getUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr);
 
260
}
 
261
 
 
262
- (void)setReflectedUnsignedIntegralAttr:(unsigned)newReflectedUnsignedIntegralAttr
 
263
{
 
264
    WebCore::JSMainThreadNullState state;
 
265
    IMPL->setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, newReflectedUnsignedIntegralAttr);
 
266
}
 
267
 
 
268
- (BOOL)reflectedBooleanAttr
 
269
{
 
270
    WebCore::JSMainThreadNullState state;
 
271
    return IMPL->hasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr);
 
272
}
 
273
 
 
274
- (void)setReflectedBooleanAttr:(BOOL)newReflectedBooleanAttr
 
275
{
 
276
    WebCore::JSMainThreadNullState state;
 
277
    IMPL->setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, newReflectedBooleanAttr);
 
278
}
 
279
 
 
280
- (NSString *)reflectedURLAttr
 
281
{
 
282
    WebCore::JSMainThreadNullState state;
 
283
    return IMPL->getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr);
 
284
}
 
285
 
 
286
- (void)setReflectedURLAttr:(NSString *)newReflectedURLAttr
 
287
{
 
288
    WebCore::JSMainThreadNullState state;
 
289
    IMPL->setAttribute(WebCore::HTMLNames::reflectedurlattrAttr, newReflectedURLAttr);
 
290
}
 
291
 
 
292
- (NSString *)reflectedStringAttr
 
293
{
 
294
    WebCore::JSMainThreadNullState state;
 
295
    return IMPL->getAttribute(WebCore::HTMLNames::customContentStringAttrAttr);
 
296
}
 
297
 
 
298
- (void)setReflectedStringAttr:(NSString *)newReflectedStringAttr
 
299
{
 
300
    WebCore::JSMainThreadNullState state;
 
301
    IMPL->setAttribute(WebCore::HTMLNames::customContentStringAttrAttr, newReflectedStringAttr);
 
302
}
 
303
 
 
304
- (int)reflectedCustomIntegralAttr
 
305
{
 
306
    WebCore::JSMainThreadNullState state;
 
307
    return IMPL->getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr);
 
308
}
 
309
 
 
310
- (void)setReflectedCustomIntegralAttr:(int)newReflectedCustomIntegralAttr
 
311
{
 
312
    WebCore::JSMainThreadNullState state;
 
313
    IMPL->setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, newReflectedCustomIntegralAttr);
 
314
}
 
315
 
 
316
- (BOOL)reflectedCustomBooleanAttr
 
317
{
 
318
    WebCore::JSMainThreadNullState state;
 
319
    return IMPL->hasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr);
 
320
}
 
321
 
 
322
- (void)setReflectedCustomBooleanAttr:(BOOL)newReflectedCustomBooleanAttr
 
323
{
 
324
    WebCore::JSMainThreadNullState state;
 
325
    IMPL->setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, newReflectedCustomBooleanAttr);
 
326
}
 
327
 
 
328
- (NSString *)reflectedCustomURLAttr
 
329
{
 
330
    WebCore::JSMainThreadNullState state;
 
331
    return IMPL->getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr);
 
332
}
 
333
 
 
334
- (void)setReflectedCustomURLAttr:(NSString *)newReflectedCustomURLAttr
 
335
{
 
336
    WebCore::JSMainThreadNullState state;
 
337
    IMPL->setAttribute(WebCore::HTMLNames::customContentURLAttrAttr, newReflectedCustomURLAttr);
 
338
}
 
339
 
 
340
- (int)attrWithGetterException
 
341
{
 
342
    WebCore::JSMainThreadNullState state;
 
343
    WebCore::ExceptionCode ec = 0;
 
344
    int result = IMPL->attrWithGetterException(ec);
 
345
    WebCore::raiseOnDOMError(ec);
 
346
    return result;
 
347
}
 
348
 
 
349
- (void)setAttrWithGetterException:(int)newAttrWithGetterException
 
350
{
 
351
    WebCore::JSMainThreadNullState state;
 
352
    IMPL->setAttrWithGetterException(newAttrWithGetterException);
 
353
}
 
354
 
 
355
- (int)attrWithSetterException
 
356
{
 
357
    WebCore::JSMainThreadNullState state;
 
358
    return IMPL->attrWithSetterException();
 
359
}
 
360
 
 
361
- (void)setAttrWithSetterException:(int)newAttrWithSetterException
 
362
{
 
363
    WebCore::JSMainThreadNullState state;
 
364
    WebCore::ExceptionCode ec = 0;
 
365
    IMPL->setAttrWithSetterException(newAttrWithSetterException, ec);
 
366
    WebCore::raiseOnDOMError(ec);
 
367
}
 
368
 
 
369
- (NSString *)stringAttrWithGetterException
 
370
{
 
371
    WebCore::JSMainThreadNullState state;
 
372
    WebCore::ExceptionCode ec = 0;
 
373
    NSString *result = IMPL->stringAttrWithGetterException(ec);
 
374
    WebCore::raiseOnDOMError(ec);
 
375
    return result;
 
376
}
 
377
 
 
378
- (void)setStringAttrWithGetterException:(NSString *)newStringAttrWithGetterException
 
379
{
 
380
    WebCore::JSMainThreadNullState state;
 
381
    IMPL->setStringAttrWithGetterException(newStringAttrWithGetterException);
 
382
}
 
383
 
 
384
- (NSString *)stringAttrWithSetterException
 
385
{
 
386
    WebCore::JSMainThreadNullState state;
 
387
    return IMPL->stringAttrWithSetterException();
 
388
}
 
389
 
 
390
- (void)setStringAttrWithSetterException:(NSString *)newStringAttrWithSetterException
 
391
{
 
392
    WebCore::JSMainThreadNullState state;
 
393
    WebCore::ExceptionCode ec = 0;
 
394
    IMPL->setStringAttrWithSetterException(newStringAttrWithSetterException, ec);
 
395
    WebCore::raiseOnDOMError(ec);
 
396
}
 
397
 
 
398
- (int)customAttr
 
399
{
 
400
    WebCore::JSMainThreadNullState state;
 
401
    return IMPL->customAttr();
 
402
}
 
403
 
 
404
- (void)setCustomAttr:(int)newCustomAttr
 
405
{
 
406
    WebCore::JSMainThreadNullState state;
 
407
    IMPL->setCustomAttr(newCustomAttr);
 
408
}
 
409
 
 
410
- (int)withScriptStateAttribute
 
411
{
 
412
    WebCore::JSMainThreadNullState state;
 
413
    return IMPL->withScriptStateAttribute();
 
414
}
 
415
 
 
416
- (void)setWithScriptStateAttribute:(int)newWithScriptStateAttribute
 
417
{
 
418
    WebCore::JSMainThreadNullState state;
 
419
    IMPL->setWithScriptStateAttribute(newWithScriptStateAttribute);
 
420
}
 
421
 
 
422
- (DOMTestObj *)withScriptExecutionContextAttribute
 
423
{
 
424
    WebCore::JSMainThreadNullState state;
 
425
    return kit(WTF::getPtr(IMPL->withScriptExecutionContextAttribute()));
 
426
}
 
427
 
 
428
- (void)setWithScriptExecutionContextAttribute:(DOMTestObj *)newWithScriptExecutionContextAttribute
 
429
{
 
430
    WebCore::JSMainThreadNullState state;
 
431
    ASSERT(newWithScriptExecutionContextAttribute);
 
432
 
 
433
    IMPL->setWithScriptExecutionContextAttribute(core(newWithScriptExecutionContextAttribute));
 
434
}
 
435
 
 
436
- (DOMTestObj *)withScriptStateAttributeRaises
 
437
{
 
438
    WebCore::JSMainThreadNullState state;
 
439
    WebCore::ExceptionCode ec = 0;
 
440
    DOMTestObj *result = kit(WTF::getPtr(IMPL->withScriptStateAttributeRaises(ec)));
 
441
    WebCore::raiseOnDOMError(ec);
 
442
    return result;
 
443
}
 
444
 
 
445
- (void)setWithScriptStateAttributeRaises:(DOMTestObj *)newWithScriptStateAttributeRaises
 
446
{
 
447
    WebCore::JSMainThreadNullState state;
 
448
    ASSERT(newWithScriptStateAttributeRaises);
 
449
 
 
450
    IMPL->setWithScriptStateAttributeRaises(core(newWithScriptStateAttributeRaises));
 
451
}
 
452
 
 
453
- (DOMTestObj *)withScriptExecutionContextAttributeRaises
 
454
{
 
455
    WebCore::JSMainThreadNullState state;
 
456
    WebCore::ExceptionCode ec = 0;
 
457
    DOMTestObj *result = kit(WTF::getPtr(IMPL->withScriptExecutionContextAttributeRaises(ec)));
 
458
    WebCore::raiseOnDOMError(ec);
 
459
    return result;
 
460
}
 
461
 
 
462
- (void)setWithScriptExecutionContextAttributeRaises:(DOMTestObj *)newWithScriptExecutionContextAttributeRaises
 
463
{
 
464
    WebCore::JSMainThreadNullState state;
 
465
    ASSERT(newWithScriptExecutionContextAttributeRaises);
 
466
 
 
467
    IMPL->setWithScriptExecutionContextAttributeRaises(core(newWithScriptExecutionContextAttributeRaises));
 
468
}
 
469
 
 
470
- (DOMTestObj *)withScriptExecutionContextAndScriptStateAttribute
 
471
{
 
472
    WebCore::JSMainThreadNullState state;
 
473
    return kit(WTF::getPtr(IMPL->withScriptExecutionContextAndScriptStateAttribute()));
 
474
}
 
475
 
 
476
- (void)setWithScriptExecutionContextAndScriptStateAttribute:(DOMTestObj *)newWithScriptExecutionContextAndScriptStateAttribute
 
477
{
 
478
    WebCore::JSMainThreadNullState state;
 
479
    ASSERT(newWithScriptExecutionContextAndScriptStateAttribute);
 
480
 
 
481
    IMPL->setWithScriptExecutionContextAndScriptStateAttribute(core(newWithScriptExecutionContextAndScriptStateAttribute));
 
482
}
 
483
 
 
484
- (DOMTestObj *)withScriptExecutionContextAndScriptStateAttributeRaises
 
485
{
 
486
    WebCore::JSMainThreadNullState state;
 
487
    WebCore::ExceptionCode ec = 0;
 
488
    DOMTestObj *result = kit(WTF::getPtr(IMPL->withScriptExecutionContextAndScriptStateAttributeRaises(ec)));
 
489
    WebCore::raiseOnDOMError(ec);
 
490
    return result;
 
491
}
 
492
 
 
493
- (void)setWithScriptExecutionContextAndScriptStateAttributeRaises:(DOMTestObj *)newWithScriptExecutionContextAndScriptStateAttributeRaises
 
494
{
 
495
    WebCore::JSMainThreadNullState state;
 
496
    ASSERT(newWithScriptExecutionContextAndScriptStateAttributeRaises);
 
497
 
 
498
    IMPL->setWithScriptExecutionContextAndScriptStateAttributeRaises(core(newWithScriptExecutionContextAndScriptStateAttributeRaises));
 
499
}
 
500
 
 
501
- (DOMTestObj *)withScriptExecutionContextAndScriptStateWithSpacesAttribute
 
502
{
 
503
    WebCore::JSMainThreadNullState state;
 
504
    return kit(WTF::getPtr(IMPL->withScriptExecutionContextAndScriptStateWithSpacesAttribute()));
 
505
}
 
506
 
 
507
- (void)setWithScriptExecutionContextAndScriptStateWithSpacesAttribute:(DOMTestObj *)newWithScriptExecutionContextAndScriptStateWithSpacesAttribute
 
508
{
 
509
    WebCore::JSMainThreadNullState state;
 
510
    ASSERT(newWithScriptExecutionContextAndScriptStateWithSpacesAttribute);
 
511
 
 
512
    IMPL->setWithScriptExecutionContextAndScriptStateWithSpacesAttribute(core(newWithScriptExecutionContextAndScriptStateWithSpacesAttribute));
 
513
}
 
514
 
 
515
- (DOMTestObj *)withScriptArgumentsAndCallStackAttribute
 
516
{
 
517
    WebCore::JSMainThreadNullState state;
 
518
    return kit(WTF::getPtr(IMPL->withScriptArgumentsAndCallStackAttribute()));
 
519
}
 
520
 
 
521
- (void)setWithScriptArgumentsAndCallStackAttribute:(DOMTestObj *)newWithScriptArgumentsAndCallStackAttribute
 
522
{
 
523
    WebCore::JSMainThreadNullState state;
 
524
    ASSERT(newWithScriptArgumentsAndCallStackAttribute);
 
525
 
 
526
    IMPL->setWithScriptArgumentsAndCallStackAttribute(core(newWithScriptArgumentsAndCallStackAttribute));
 
527
}
 
528
 
 
529
#if ENABLE(Condition1)
 
530
- (int)conditionalAttr1
 
531
{
 
532
    WebCore::JSMainThreadNullState state;
 
533
    return IMPL->conditionalAttr1();
 
534
}
 
535
 
 
536
- (void)setConditionalAttr1:(int)newConditionalAttr1
 
537
{
 
538
    WebCore::JSMainThreadNullState state;
 
539
    IMPL->setConditionalAttr1(newConditionalAttr1);
 
540
}
 
541
#endif
 
542
 
 
543
#if ENABLE(Condition1) && ENABLE(Condition2)
 
544
- (int)conditionalAttr2
 
545
{
 
546
    WebCore::JSMainThreadNullState state;
 
547
    return IMPL->conditionalAttr2();
 
548
}
 
549
 
 
550
- (void)setConditionalAttr2:(int)newConditionalAttr2
 
551
{
 
552
    WebCore::JSMainThreadNullState state;
 
553
    IMPL->setConditionalAttr2(newConditionalAttr2);
 
554
}
 
555
#endif
 
556
 
 
557
#if ENABLE(Condition1) || ENABLE(Condition2)
 
558
- (int)conditionalAttr3
 
559
{
 
560
    WebCore::JSMainThreadNullState state;
 
561
    return IMPL->conditionalAttr3();
 
562
}
 
563
 
 
564
- (void)setConditionalAttr3:(int)newConditionalAttr3
 
565
{
 
566
    WebCore::JSMainThreadNullState state;
 
567
    IMPL->setConditionalAttr3(newConditionalAttr3);
 
568
}
 
569
#endif
 
570
 
 
571
#if ENABLE(Condition1)
 
572
- (DOMTestObjectAConstructor *)conditionalAttr4
 
573
{
 
574
    WebCore::JSMainThreadNullState state;
 
575
    return kit(WTF::getPtr(IMPL->conditionalAttr4()));
 
576
}
 
577
 
 
578
- (void)setConditionalAttr4:(DOMTestObjectAConstructor *)newConditionalAttr4
 
579
{
 
580
    WebCore::JSMainThreadNullState state;
 
581
    ASSERT(newConditionalAttr4);
 
582
 
 
583
    IMPL->setConditionalAttr4(core(newConditionalAttr4));
 
584
}
 
585
#endif
 
586
 
 
587
#if ENABLE(Condition1) && ENABLE(Condition2)
 
588
- (DOMTestObjectBConstructor *)conditionalAttr5
 
589
{
 
590
    WebCore::JSMainThreadNullState state;
 
591
    return kit(WTF::getPtr(IMPL->conditionalAttr5()));
 
592
}
 
593
 
 
594
- (void)setConditionalAttr5:(DOMTestObjectBConstructor *)newConditionalAttr5
 
595
{
 
596
    WebCore::JSMainThreadNullState state;
 
597
    ASSERT(newConditionalAttr5);
 
598
 
 
599
    IMPL->setConditionalAttr5(core(newConditionalAttr5));
 
600
}
 
601
#endif
 
602
 
 
603
#if ENABLE(Condition1) || ENABLE(Condition2)
 
604
- (DOMTestObjectCConstructor *)conditionalAttr6
 
605
{
 
606
    WebCore::JSMainThreadNullState state;
 
607
    return kit(WTF::getPtr(IMPL->conditionalAttr6()));
 
608
}
 
609
 
 
610
- (void)setConditionalAttr6:(DOMTestObjectCConstructor *)newConditionalAttr6
 
611
{
 
612
    WebCore::JSMainThreadNullState state;
 
613
    ASSERT(newConditionalAttr6);
 
614
 
 
615
    IMPL->setConditionalAttr6(core(newConditionalAttr6));
 
616
}
 
617
#endif
 
618
 
 
619
- (DOMany *)anyAttribute
 
620
{
 
621
    WebCore::JSMainThreadNullState state;
 
622
    return kit(WTF::getPtr(IMPL->anyAttribute()));
 
623
}
 
624
 
 
625
- (void)setAnyAttribute:(DOMany *)newAnyAttribute
 
626
{
 
627
    WebCore::JSMainThreadNullState state;
 
628
    ASSERT(newAnyAttribute);
 
629
 
 
630
    IMPL->setAnyAttribute(core(newAnyAttribute));
 
631
}
 
632
 
 
633
- (DOMDocument *)contentDocument
 
634
{
 
635
    WebCore::JSMainThreadNullState state;
 
636
    return kit(WTF::getPtr(IMPL->contentDocument()));
 
637
}
 
638
 
 
639
- (DOMSVGPoint *)mutablePoint
 
640
{
 
641
    WebCore::JSMainThreadNullState state;
 
642
    return kit(WTF::getPtr(WebCore::SVGStaticPropertyTearOff<WebCore::TestObj, WebCore::FloatPoint>::create(IMPL, IMPL->mutablePoint(), &WebCore::TestObj::updateMutablePoint)));
 
643
}
 
644
 
 
645
- (void)setMutablePoint:(DOMSVGPoint *)newMutablePoint
 
646
{
 
647
    WebCore::JSMainThreadNullState state;
 
648
    ASSERT(newMutablePoint);
 
649
 
 
650
    IMPL->setMutablePoint(core(newMutablePoint));
 
651
}
 
652
 
 
653
- (DOMSVGPoint *)immutablePoint
 
654
{
 
655
    WebCore::JSMainThreadNullState state;
 
656
    return kit(WTF::getPtr(WebCore::SVGPropertyTearOff<WebCore::FloatPoint>::create(IMPL->immutablePoint())));
 
657
}
 
658
 
 
659
- (void)setImmutablePoint:(DOMSVGPoint *)newImmutablePoint
 
660
{
 
661
    WebCore::JSMainThreadNullState state;
 
662
    ASSERT(newImmutablePoint);
 
663
 
 
664
    IMPL->setImmutablePoint(core(newImmutablePoint));
 
665
}
 
666
 
 
667
- (int)strawberry
 
668
{
 
669
    WebCore::JSMainThreadNullState state;
 
670
    return IMPL->blueberry();
 
671
}
 
672
 
 
673
- (void)setStrawberry:(int)newStrawberry
 
674
{
 
675
    WebCore::JSMainThreadNullState state;
 
676
    IMPL->setBlueberry(newStrawberry);
 
677
}
 
678
 
 
679
- (float)strictFloat
 
680
{
 
681
    WebCore::JSMainThreadNullState state;
 
682
    return IMPL->strictFloat();
 
683
}
 
684
 
 
685
- (void)setStrictFloat:(float)newStrictFloat
 
686
{
 
687
    WebCore::JSMainThreadNullState state;
 
688
    IMPL->setStrictFloat(newStrictFloat);
 
689
}
 
690
 
 
691
- (int)descriptionName
 
692
{
 
693
    WebCore::JSMainThreadNullState state;
 
694
    return IMPL->description();
 
695
}
 
696
 
 
697
- (int)idName
 
698
{
 
699
    WebCore::JSMainThreadNullState state;
 
700
    return IMPL->id();
 
701
}
 
702
 
 
703
- (void)setIdName:(int)newIdName
 
704
{
 
705
    WebCore::JSMainThreadNullState state;
 
706
    IMPL->setId(newIdName);
 
707
}
 
708
 
 
709
- (NSString *)hashName
 
710
{
 
711
    WebCore::JSMainThreadNullState state;
 
712
    return IMPL->hash();
 
713
}
 
714
 
 
715
- (int)replaceableAttribute
 
716
{
 
717
    WebCore::JSMainThreadNullState state;
 
718
    return IMPL->replaceableAttribute();
 
719
}
 
720
 
 
721
- (void)voidMethod
 
722
{
 
723
    WebCore::JSMainThreadNullState state;
 
724
    IMPL->voidMethod();
 
725
}
 
726
 
 
727
- (void)voidMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
 
728
{
 
729
    WebCore::JSMainThreadNullState state;
 
730
    IMPL->voidMethodWithArgs(longArg, strArg, core(objArg));
 
731
}
 
732
 
 
733
- (int)longMethod
 
734
{
 
735
    WebCore::JSMainThreadNullState state;
 
736
    return IMPL->longMethod();
 
737
}
 
738
 
 
739
- (int)longMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
 
740
{
 
741
    WebCore::JSMainThreadNullState state;
 
742
    return IMPL->longMethodWithArgs(longArg, strArg, core(objArg));
 
743
}
 
744
 
 
745
- (DOMTestObj *)objMethod
 
746
{
 
747
    WebCore::JSMainThreadNullState state;
 
748
    return kit(WTF::getPtr(IMPL->objMethod()));
 
749
}
 
750
 
 
751
- (DOMTestObj *)objMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
 
752
{
 
753
    WebCore::JSMainThreadNullState state;
 
754
    return kit(WTF::getPtr(IMPL->objMethodWithArgs(longArg, strArg, core(objArg))));
 
755
}
 
756
 
 
757
- (DOMTestObj *)methodThatRequiresAllArgsAndThrows:(NSString *)strArg objArg:(DOMTestObj *)objArg
 
758
{
 
759
    WebCore::JSMainThreadNullState state;
 
760
    WebCore::ExceptionCode ec = 0;
 
761
    DOMTestObj *result = kit(WTF::getPtr(IMPL->methodThatRequiresAllArgsAndThrows(strArg, core(objArg), ec)));
 
762
    WebCore::raiseOnDOMError(ec);
 
763
    return result;
 
764
}
 
765
 
 
766
- (void)serializedValue:(NSString *)serializedArg
 
767
{
 
768
    WebCore::JSMainThreadNullState state;
 
769
    IMPL->serializedValue(WebCore::SerializedScriptValue::create(WTF::String(serializedArg)));
 
770
}
 
771
 
 
772
- (void)idbKey:(DOMIDBKey *)key
 
773
{
 
774
    WebCore::JSMainThreadNullState state;
 
775
    IMPL->idbKey(core(key));
 
776
}
 
777
 
 
778
- (void)optionsObject:(DOMDictionary *)oo ooo:(DOMDictionary *)ooo
 
779
{
 
780
    WebCore::JSMainThreadNullState state;
 
781
    IMPL->optionsObject(core(oo), core(ooo));
 
782
}
 
783
 
 
784
- (void)methodWithException
 
785
{
 
786
    WebCore::JSMainThreadNullState state;
 
787
    WebCore::ExceptionCode ec = 0;
 
788
    IMPL->methodWithException(ec);
 
789
    WebCore::raiseOnDOMError(ec);
 
790
}
 
791
 
 
792
- (void)customMethod
 
793
{
 
794
    WebCore::JSMainThreadNullState state;
 
795
    IMPL->customMethod();
 
796
}
 
797
 
 
798
- (void)customMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
 
799
{
 
800
    WebCore::JSMainThreadNullState state;
 
801
    IMPL->customMethodWithArgs(longArg, strArg, core(objArg));
 
802
}
 
803
 
 
804
- (void)addEventListener:(NSString *)type listener:(id <DOMEventListener>)listener useCapture:(BOOL)useCapture
 
805
{
 
806
    WebCore::JSMainThreadNullState state;
 
807
    RefPtr<WebCore::EventListener> nativeEventListener = WebCore::ObjCEventListener::wrap(listener);
 
808
    IMPL->addEventListener(type, WTF::getPtr(nativeEventListener), useCapture);
 
809
}
 
810
 
 
811
- (void)removeEventListener:(NSString *)type listener:(id <DOMEventListener>)listener useCapture:(BOOL)useCapture
 
812
{
 
813
    WebCore::JSMainThreadNullState state;
 
814
    RefPtr<WebCore::EventListener> nativeEventListener = WebCore::ObjCEventListener::wrap(listener);
 
815
    IMPL->removeEventListener(type, WTF::getPtr(nativeEventListener), useCapture);
 
816
}
 
817
 
 
818
- (void)withScriptStateVoid
 
819
{
 
820
    WebCore::JSMainThreadNullState state;
 
821
    IMPL->withScriptStateVoid();
 
822
}
 
823
 
 
824
- (DOMTestObj *)withScriptStateObj
 
825
{
 
826
    WebCore::JSMainThreadNullState state;
 
827
    return kit(WTF::getPtr(IMPL->withScriptStateObj()));
 
828
}
 
829
 
 
830
- (void)withScriptStateVoidException
 
831
{
 
832
    WebCore::JSMainThreadNullState state;
 
833
    WebCore::ExceptionCode ec = 0;
 
834
    IMPL->withScriptStateVoidException(ec);
 
835
    WebCore::raiseOnDOMError(ec);
 
836
}
 
837
 
 
838
- (DOMTestObj *)withScriptStateObjException
 
839
{
 
840
    WebCore::JSMainThreadNullState state;
 
841
    WebCore::ExceptionCode ec = 0;
 
842
    DOMTestObj *result = kit(WTF::getPtr(IMPL->withScriptStateObjException(ec)));
 
843
    WebCore::raiseOnDOMError(ec);
 
844
    return result;
 
845
}
 
846
 
 
847
- (void)withScriptExecutionContext
 
848
{
 
849
    WebCore::JSMainThreadNullState state;
 
850
    IMPL->withScriptExecutionContext();
 
851
}
 
852
 
 
853
- (void)withScriptExecutionContextAndScriptState
 
854
{
 
855
    WebCore::JSMainThreadNullState state;
 
856
    IMPL->withScriptExecutionContextAndScriptState();
 
857
}
 
858
 
 
859
- (DOMTestObj *)withScriptExecutionContextAndScriptStateObjException
 
860
{
 
861
    WebCore::JSMainThreadNullState state;
 
862
    WebCore::ExceptionCode ec = 0;
 
863
    DOMTestObj *result = kit(WTF::getPtr(IMPL->withScriptExecutionContextAndScriptStateObjException(ec)));
 
864
    WebCore::raiseOnDOMError(ec);
 
865
    return result;
 
866
}
 
867
 
 
868
- (DOMTestObj *)withScriptExecutionContextAndScriptStateWithSpaces
 
869
{
 
870
    WebCore::JSMainThreadNullState state;
 
871
    return kit(WTF::getPtr(IMPL->withScriptExecutionContextAndScriptStateWithSpaces()));
 
872
}
 
873
 
 
874
- (void)withScriptArgumentsAndCallStack
 
875
{
 
876
    WebCore::JSMainThreadNullState state;
 
877
    IMPL->withScriptArgumentsAndCallStack();
 
878
}
 
879
 
 
880
- (void)methodWithOptionalArg:(int)opt
 
881
{
 
882
    WebCore::JSMainThreadNullState state;
 
883
    IMPL->methodWithOptionalArg(opt);
 
884
}
 
885
 
 
886
- (void)methodWithNonOptionalArgAndOptionalArg:(int)nonOpt opt:(int)opt
 
887
{
 
888
    WebCore::JSMainThreadNullState state;
 
889
    IMPL->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);
 
890
}
 
891
 
 
892
- (void)methodWithNonOptionalArgAndTwoOptionalArgs:(int)nonOpt opt1:(int)opt1 opt2:(int)opt2
 
893
{
 
894
    WebCore::JSMainThreadNullState state;
 
895
    IMPL->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);
 
896
}
 
897
 
 
898
- (void)methodWithOptionalString:(NSString *)str
 
899
{
 
900
    WebCore::JSMainThreadNullState state;
 
901
    IMPL->methodWithOptionalString(str);
 
902
}
 
903
 
 
904
- (void)methodWithOptionalStringIsUndefined:(NSString *)str
 
905
{
 
906
    WebCore::JSMainThreadNullState state;
 
907
    IMPL->methodWithOptionalStringIsUndefined(str);
 
908
}
 
909
 
 
910
- (void)methodWithOptionalStringIsNullString:(NSString *)str
 
911
{
 
912
    WebCore::JSMainThreadNullState state;
 
913
    IMPL->methodWithOptionalStringIsNullString(str);
 
914
}
 
915
 
 
916
 
 
917
#if ENABLE(Condition1)
 
918
- (NSString *)conditionalMethod1
 
919
{
 
920
    WebCore::JSMainThreadNullState state;
 
921
    return IMPL->conditionalMethod1();
 
922
}
 
923
 
 
924
#endif
 
925
 
 
926
 
 
927
#if ENABLE(Condition1) && ENABLE(Condition2)
 
928
- (void)conditionalMethod2
 
929
{
 
930
    WebCore::JSMainThreadNullState state;
 
931
    IMPL->conditionalMethod2();
 
932
}
 
933
 
 
934
#endif
 
935
 
 
936
 
 
937
#if ENABLE(Condition1) || ENABLE(Condition2)
 
938
- (void)conditionalMethod3
 
939
{
 
940
    WebCore::JSMainThreadNullState state;
 
941
    IMPL->conditionalMethod3();
 
942
}
 
943
 
 
944
#endif
 
945
 
 
946
- (void)classMethod
 
947
{
 
948
    WebCore::JSMainThreadNullState state;
 
949
    IMPL->classMethod();
 
950
}
 
951
 
 
952
- (int)classMethodWithOptional:(int)arg
 
953
{
 
954
    WebCore::JSMainThreadNullState state;
 
955
    return IMPL->classMethodWithOptional(arg);
 
956
}
 
957
 
 
958
- (void)classMethod2:(int)arg
 
959
{
 
960
    WebCore::JSMainThreadNullState state;
 
961
    IMPL->classMethod2(arg);
 
962
}
 
963
 
 
964
 
 
965
#if ENABLE(Condition1)
 
966
- (void)overloadedMethod1:(int)arg
 
967
{
 
968
    WebCore::JSMainThreadNullState state;
 
969
    IMPL->overloadedMethod1(arg);
 
970
}
 
971
 
 
972
#endif
 
973
 
 
974
 
 
975
#if ENABLE(Condition1)
 
976
- (void)overloadedMethod1:(NSString *)type
 
977
{
 
978
    WebCore::JSMainThreadNullState state;
 
979
    IMPL->overloadedMethod1(type);
 
980
}
 
981
 
 
982
#endif
 
983
 
 
984
- (DOMSVGDocument *)getSVGDocument
 
985
{
 
986
    WebCore::JSMainThreadNullState state;
 
987
    WebCore::ExceptionCode ec = 0;
 
988
    DOMSVGDocument *result = kit(WTF::getPtr(IMPL->getSVGDocument(ec)));
 
989
    WebCore::raiseOnDOMError(ec);
 
990
    return result;
 
991
}
 
992
 
 
993
- (void)convert1:(DOMa *)value
 
994
{
 
995
    WebCore::JSMainThreadNullState state;
 
996
    IMPL->convert1(core(value));
 
997
}
 
998
 
 
999
- (void)convert2:(DOMb *)value
 
1000
{
 
1001
    WebCore::JSMainThreadNullState state;
 
1002
    IMPL->convert2(core(value));
 
1003
}
 
1004
 
 
1005
- (void)convert4:(DOMd *)value
 
1006
{
 
1007
    WebCore::JSMainThreadNullState state;
 
1008
    IMPL->convert4(core(value));
 
1009
}
 
1010
 
 
1011
- (void)convert5:(DOMe *)value
 
1012
{
 
1013
    WebCore::JSMainThreadNullState state;
 
1014
    IMPL->convert5(core(value));
 
1015
}
 
1016
 
 
1017
- (DOMSVGPoint *)mutablePointFunction
 
1018
{
 
1019
    WebCore::JSMainThreadNullState state;
 
1020
    return kit(WTF::getPtr(WebCore::SVGPropertyTearOff<WebCore::FloatPoint>::create(IMPL->mutablePointFunction())));
 
1021
}
 
1022
 
 
1023
- (DOMSVGPoint *)immutablePointFunction
 
1024
{
 
1025
    WebCore::JSMainThreadNullState state;
 
1026
    return kit(WTF::getPtr(WebCore::SVGPropertyTearOff<WebCore::FloatPoint>::create(IMPL->immutablePointFunction())));
 
1027
}
 
1028
 
 
1029
- (void)orange
 
1030
{
 
1031
    WebCore::JSMainThreadNullState state;
 
1032
    IMPL->orange();
 
1033
}
 
1034
 
 
1035
- (DOMbool *)strictFunction:(NSString *)str a:(float)a b:(int)b
 
1036
{
 
1037
    WebCore::JSMainThreadNullState state;
 
1038
    WebCore::ExceptionCode ec = 0;
 
1039
    DOMbool *result = kit(WTF::getPtr(IMPL->strictFunction(str, a, b, ec)));
 
1040
    WebCore::raiseOnDOMError(ec);
 
1041
    return result;
 
1042
}
 
1043
 
 
1044
- (void)variadicStringMethod:(NSString *)head tail:(NSString *)tail
 
1045
{
 
1046
    WebCore::JSMainThreadNullState state;
 
1047
    IMPL->variadicStringMethod(head, tail);
 
1048
}
 
1049
 
 
1050
- (void)variadicDoubleMethod:(double)head tail:(double)tail
 
1051
{
 
1052
    WebCore::JSMainThreadNullState state;
 
1053
    IMPL->variadicDoubleMethod(head, tail);
 
1054
}
 
1055
 
 
1056
- (void)variadicNodeMethod:(DOMNode *)head tail:(DOMNode *)tail
 
1057
{
 
1058
    WebCore::JSMainThreadNullState state;
 
1059
    IMPL->variadicNodeMethod(core(head), core(tail));
 
1060
}
 
1061
 
 
1062
@end
 
1063
 
 
1064
WebCore::TestObj* core(DOMTestObj *wrapper)
 
1065
{
 
1066
    return wrapper ? reinterpret_cast<WebCore::TestObj*>(wrapper->_internal) : 0;
 
1067
}
 
1068
 
 
1069
DOMTestObj *kit(WebCore::TestObj* value)
 
1070
{
 
1071
    { DOM_ASSERT_MAIN_THREAD(); WebCoreThreadViolationCheckRoundOne(); };
 
1072
    if (!value)
 
1073
        return nil;
 
1074
    if (DOMTestObj *wrapper = getDOMWrapper(value))
 
1075
        return [[wrapper retain] autorelease];
 
1076
    DOMTestObj *wrapper = [[DOMTestObj alloc] _init];
 
1077
    wrapper->_internal = reinterpret_cast<DOMObjectInternal*>(value);
 
1078
    value->ref();
 
1079
    addDOMWrapper(wrapper, value);
 
1080
    return [wrapper autorelease];
 
1081
}