← 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/JSMouseEvent.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/JSMouseEvent.cpp
19
19
*/
20
20
 
21
21
#include "config.h"
22
 
 
23
22
#include "JSMouseEvent.h"
24
23
 
25
 
#include <wtf/GetPtr.h>
26
 
 
27
24
#include "Clipboard.h"
28
25
#include "EventTarget.h"
29
26
#include "JSClipboard.h"
30
27
#include "JSDOMWindow.h"
31
28
#include "JSEventTarget.h"
32
 
#include "JSEventTargetNode.h"
33
29
#include "JSNode.h"
34
30
#include "MouseEvent.h"
35
31
#include "Node.h"
36
 
 
37
32
#include <runtime/Error.h>
38
33
#include <runtime/JSNumberCell.h>
 
34
#include <wtf/GetPtr.h>
39
35
 
40
36
using namespace JSC;
41
37
 
42
38
namespace WebCore {
43
39
 
44
 
ASSERT_CLASS_FITS_IN_CELL(JSMouseEvent)
 
40
ASSERT_CLASS_FITS_IN_CELL(JSMouseEvent);
45
41
 
46
42
/* Hash table */
47
43
 
68
64
    { 0, 0, 0, 0 }
69
65
};
70
66
 
71
 
static const HashTable JSMouseEventTable =
 
67
static JSC_CONST_HASHTABLE HashTable JSMouseEventTable =
72
68
#if ENABLE(PERFECT_HASH_SIZE)
73
69
    { 127, JSMouseEventTableValues, 0 };
74
70
#else
82
78
    { 0, 0, 0, 0 }
83
79
};
84
80
 
85
 
static const HashTable JSMouseEventConstructorTable =
 
81
static JSC_CONST_HASHTABLE HashTable JSMouseEventConstructorTable =
86
82
#if ENABLE(PERFECT_HASH_SIZE)
87
83
    { 0, JSMouseEventConstructorTableValues, 0 };
88
84
#else
89
85
    { 1, 0, JSMouseEventConstructorTableValues, 0 };
90
86
#endif
91
87
 
92
 
class JSMouseEventConstructor : public DOMObject {
 
88
class JSMouseEventConstructor : public DOMConstructorObject {
93
89
public:
94
 
    JSMouseEventConstructor(ExecState* exec)
95
 
        : DOMObject(JSMouseEventConstructor::createStructure(exec->lexicalGlobalObject()->objectPrototype()))
 
90
    JSMouseEventConstructor(ExecState* exec, JSDOMGlobalObject* globalObject)
 
91
        : DOMConstructorObject(JSMouseEventConstructor::createStructure(globalObject->objectPrototype()), globalObject)
96
92
    {
97
 
        putDirect(exec->propertyNames().prototype, JSMouseEventPrototype::self(exec, exec->lexicalGlobalObject()), None);
 
93
        putDirect(exec->propertyNames().prototype, JSMouseEventPrototype::self(exec, globalObject), None);
98
94
    }
99
95
    virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 
96
    virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
100
97
    virtual const ClassInfo* classInfo() const { return &s_info; }
101
98
    static const ClassInfo s_info;
102
99
 
103
 
    static PassRefPtr<Structure> createStructure(JSValuePtr proto) 
 
100
    static PassRefPtr<Structure> createStructure(JSValue proto) 
104
101
    { 
105
102
        return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance)); 
106
103
    }
113
110
    return getStaticValueSlot<JSMouseEventConstructor, DOMObject>(exec, &JSMouseEventConstructorTable, this, propertyName, slot);
114
111
}
115
112
 
 
113
bool JSMouseEventConstructor::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
114
{
 
115
    return getStaticValueDescriptor<JSMouseEventConstructor, DOMObject>(exec, &JSMouseEventConstructorTable, this, propertyName, descriptor);
 
116
}
 
117
 
116
118
/* Hash table for prototype */
117
119
 
118
120
static const HashTableValue JSMouseEventPrototypeTableValues[2] =
121
123
    { 0, 0, 0, 0 }
122
124
};
123
125
 
124
 
static const HashTable JSMouseEventPrototypeTable =
 
126
static JSC_CONST_HASHTABLE HashTable JSMouseEventPrototypeTable =
125
127
#if ENABLE(PERFECT_HASH_SIZE)
126
128
    { 0, JSMouseEventPrototypeTableValues, 0 };
127
129
#else
140
142
    return getStaticFunctionSlot<JSObject>(exec, &JSMouseEventPrototypeTable, this, propertyName, slot);
141
143
}
142
144
 
 
145
bool JSMouseEventPrototype::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
146
{
 
147
    return getStaticFunctionDescriptor<JSObject>(exec, &JSMouseEventPrototypeTable, this, propertyName, descriptor);
 
148
}
 
149
 
143
150
const ClassInfo JSMouseEvent::s_info = { "MouseEvent", &JSUIEvent::s_info, &JSMouseEventTable, 0 };
144
151
 
145
 
JSMouseEvent::JSMouseEvent(PassRefPtr<Structure> structure, PassRefPtr<MouseEvent> impl)
146
 
    : JSUIEvent(structure, impl)
 
152
JSMouseEvent::JSMouseEvent(NonNullPassRefPtr<Structure> structure, JSDOMGlobalObject* globalObject, PassRefPtr<MouseEvent> impl)
 
153
    : JSUIEvent(structure, globalObject, impl)
147
154
{
148
155
}
149
156
 
157
164
    return getStaticValueSlot<JSMouseEvent, Base>(exec, &JSMouseEventTable, this, propertyName, slot);
158
165
}
159
166
 
160
 
JSValuePtr jsMouseEventScreenX(ExecState* exec, const Identifier&, const PropertySlot& slot)
161
 
{
162
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
167
bool JSMouseEvent::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 
168
{
 
169
    return getStaticValueDescriptor<JSMouseEvent, Base>(exec, &JSMouseEventTable, this, propertyName, descriptor);
 
170
}
 
171
 
 
172
JSValue jsMouseEventScreenX(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
173
{
 
174
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
175
    UNUSED_PARAM(exec);
 
176
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
163
177
    return jsNumber(exec, imp->screenX());
164
178
}
165
179
 
166
 
JSValuePtr jsMouseEventScreenY(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
180
JSValue jsMouseEventScreenY(ExecState* exec, const Identifier&, const PropertySlot& slot)
167
181
{
168
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
182
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
183
    UNUSED_PARAM(exec);
 
184
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
169
185
    return jsNumber(exec, imp->screenY());
170
186
}
171
187
 
172
 
JSValuePtr jsMouseEventClientX(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
188
JSValue jsMouseEventClientX(ExecState* exec, const Identifier&, const PropertySlot& slot)
173
189
{
174
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
190
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
191
    UNUSED_PARAM(exec);
 
192
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
175
193
    return jsNumber(exec, imp->clientX());
176
194
}
177
195
 
178
 
JSValuePtr jsMouseEventClientY(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
196
JSValue jsMouseEventClientY(ExecState* exec, const Identifier&, const PropertySlot& slot)
179
197
{
180
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
198
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
199
    UNUSED_PARAM(exec);
 
200
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
181
201
    return jsNumber(exec, imp->clientY());
182
202
}
183
203
 
184
 
JSValuePtr jsMouseEventCtrlKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
204
JSValue jsMouseEventCtrlKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
185
205
{
186
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
206
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
207
    UNUSED_PARAM(exec);
 
208
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
187
209
    return jsBoolean(imp->ctrlKey());
188
210
}
189
211
 
190
 
JSValuePtr jsMouseEventShiftKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
212
JSValue jsMouseEventShiftKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
191
213
{
192
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
214
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
215
    UNUSED_PARAM(exec);
 
216
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
193
217
    return jsBoolean(imp->shiftKey());
194
218
}
195
219
 
196
 
JSValuePtr jsMouseEventAltKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
220
JSValue jsMouseEventAltKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
197
221
{
198
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
222
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
223
    UNUSED_PARAM(exec);
 
224
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
199
225
    return jsBoolean(imp->altKey());
200
226
}
201
227
 
202
 
JSValuePtr jsMouseEventMetaKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
228
JSValue jsMouseEventMetaKey(ExecState* exec, const Identifier&, const PropertySlot& slot)
203
229
{
204
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
230
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
231
    UNUSED_PARAM(exec);
 
232
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
205
233
    return jsBoolean(imp->metaKey());
206
234
}
207
235
 
208
 
JSValuePtr jsMouseEventButton(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
236
JSValue jsMouseEventButton(ExecState* exec, const Identifier&, const PropertySlot& slot)
209
237
{
210
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
238
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
239
    UNUSED_PARAM(exec);
 
240
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
211
241
    return jsNumber(exec, imp->button());
212
242
}
213
243
 
214
 
JSValuePtr jsMouseEventRelatedTarget(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
244
JSValue jsMouseEventRelatedTarget(ExecState* exec, const Identifier&, const PropertySlot& slot)
215
245
{
216
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
217
 
    return toJS(exec, WTF::getPtr(imp->relatedTarget()));
 
246
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
247
    UNUSED_PARAM(exec);
 
248
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
 
249
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->relatedTarget()));
218
250
}
219
251
 
220
 
JSValuePtr jsMouseEventOffsetX(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
252
JSValue jsMouseEventOffsetX(ExecState* exec, const Identifier&, const PropertySlot& slot)
221
253
{
222
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
254
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
255
    UNUSED_PARAM(exec);
 
256
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
223
257
    return jsNumber(exec, imp->offsetX());
224
258
}
225
259
 
226
 
JSValuePtr jsMouseEventOffsetY(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
260
JSValue jsMouseEventOffsetY(ExecState* exec, const Identifier&, const PropertySlot& slot)
227
261
{
228
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
262
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
263
    UNUSED_PARAM(exec);
 
264
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
229
265
    return jsNumber(exec, imp->offsetY());
230
266
}
231
267
 
232
 
JSValuePtr jsMouseEventX(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
268
JSValue jsMouseEventX(ExecState* exec, const Identifier&, const PropertySlot& slot)
233
269
{
234
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
270
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
271
    UNUSED_PARAM(exec);
 
272
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
235
273
    return jsNumber(exec, imp->x());
236
274
}
237
275
 
238
 
JSValuePtr jsMouseEventY(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
276
JSValue jsMouseEventY(ExecState* exec, const Identifier&, const PropertySlot& slot)
239
277
{
240
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
 
278
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
279
    UNUSED_PARAM(exec);
 
280
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
241
281
    return jsNumber(exec, imp->y());
242
282
}
243
283
 
244
 
JSValuePtr jsMouseEventFromElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
245
 
{
246
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
247
 
    return toJS(exec, WTF::getPtr(imp->fromElement()));
248
 
}
249
 
 
250
 
JSValuePtr jsMouseEventToElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
251
 
{
252
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
253
 
    return toJS(exec, WTF::getPtr(imp->toElement()));
254
 
}
255
 
 
256
 
JSValuePtr jsMouseEventDataTransfer(ExecState* exec, const Identifier&, const PropertySlot& slot)
257
 
{
258
 
    MouseEvent* imp = static_cast<MouseEvent*>(static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->impl());
259
 
    return toJS(exec, WTF::getPtr(imp->dataTransfer()));
260
 
}
261
 
 
262
 
JSValuePtr jsMouseEventConstructor(ExecState* exec, const Identifier&, const PropertySlot& slot)
263
 
{
264
 
    return static_cast<JSMouseEvent*>(asObject(slot.slotBase()))->getConstructor(exec);
265
 
}
266
 
JSValuePtr JSMouseEvent::getConstructor(ExecState* exec)
267
 
{
268
 
    return getDOMConstructor<JSMouseEventConstructor>(exec);
269
 
}
270
 
 
271
 
JSValuePtr jsMouseEventPrototypeFunctionInitMouseEvent(ExecState* exec, JSObject*, JSValuePtr thisValue, const ArgList& args)
272
 
{
273
 
    if (!thisValue->isObject(&JSMouseEvent::s_info))
 
284
JSValue jsMouseEventFromElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
285
{
 
286
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
287
    UNUSED_PARAM(exec);
 
288
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
 
289
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->fromElement()));
 
290
}
 
291
 
 
292
JSValue jsMouseEventToElement(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
293
{
 
294
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
295
    UNUSED_PARAM(exec);
 
296
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
 
297
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->toElement()));
 
298
}
 
299
 
 
300
JSValue jsMouseEventDataTransfer(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
301
{
 
302
    JSMouseEvent* castedThis = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
303
    UNUSED_PARAM(exec);
 
304
    MouseEvent* imp = static_cast<MouseEvent*>(castedThis->impl());
 
305
    return toJS(exec, castedThis->globalObject(), WTF::getPtr(imp->dataTransfer()));
 
306
}
 
307
 
 
308
JSValue jsMouseEventConstructor(ExecState* exec, const Identifier&, const PropertySlot& slot)
 
309
{
 
310
    JSMouseEvent* domObject = static_cast<JSMouseEvent*>(asObject(slot.slotBase()));
 
311
    return JSMouseEvent::getConstructor(exec, domObject->globalObject());
 
312
}
 
313
JSValue JSMouseEvent::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
 
314
{
 
315
    return getDOMConstructor<JSMouseEventConstructor>(exec, static_cast<JSDOMGlobalObject*>(globalObject));
 
316
}
 
317
 
 
318
JSValue JSC_HOST_CALL jsMouseEventPrototypeFunctionInitMouseEvent(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
 
319
{
 
320
    UNUSED_PARAM(args);
 
321
    if (!thisValue.inherits(&JSMouseEvent::s_info))
274
322
        return throwError(exec, TypeError);
275
323
    JSMouseEvent* castedThisObj = static_cast<JSMouseEvent*>(asObject(thisValue));
276
324
    MouseEvent* imp = static_cast<MouseEvent*>(castedThisObj->impl());
277
 
    const UString& type = args.at(exec, 0)->toString(exec);
278
 
    bool canBubble = args.at(exec, 1)->toBoolean(exec);
279
 
    bool cancelable = args.at(exec, 2)->toBoolean(exec);
280
 
    DOMWindow* view = toDOMWindow(args.at(exec, 3));
281
 
    int detail = args.at(exec, 4)->toInt32(exec);
282
 
    int screenX = args.at(exec, 5)->toInt32(exec);
283
 
    int screenY = args.at(exec, 6)->toInt32(exec);
284
 
    int clientX = args.at(exec, 7)->toInt32(exec);
285
 
    int clientY = args.at(exec, 8)->toInt32(exec);
286
 
    bool ctrlKey = args.at(exec, 9)->toBoolean(exec);
287
 
    bool altKey = args.at(exec, 10)->toBoolean(exec);
288
 
    bool shiftKey = args.at(exec, 11)->toBoolean(exec);
289
 
    bool metaKey = args.at(exec, 12)->toBoolean(exec);
290
 
    unsigned short button = args.at(exec, 13)->toInt32(exec);
291
 
    EventTargetNode* relatedTarget = toEventTargetNode(args.at(exec, 14));
 
325
    const UString& type = args.at(0).toString(exec);
 
326
    bool canBubble = args.at(1).toBoolean(exec);
 
327
    bool cancelable = args.at(2).toBoolean(exec);
 
328
    DOMWindow* view = toDOMWindow(args.at(3));
 
329
    int detail = args.at(4).toInt32(exec);
 
330
    int screenX = args.at(5).toInt32(exec);
 
331
    int screenY = args.at(6).toInt32(exec);
 
332
    int clientX = args.at(7).toInt32(exec);
 
333
    int clientY = args.at(8).toInt32(exec);
 
334
    bool ctrlKey = args.at(9).toBoolean(exec);
 
335
    bool altKey = args.at(10).toBoolean(exec);
 
336
    bool shiftKey = args.at(11).toBoolean(exec);
 
337
    bool metaKey = args.at(12).toBoolean(exec);
 
338
    unsigned short button = args.at(13).toInt32(exec);
 
339
    EventTarget* relatedTarget = toEventTarget(args.at(14));
292
340
 
293
341
    imp->initMouseEvent(type, canBubble, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget);
294
342
    return jsUndefined();