← Back to branch summary

~ubuntu-branches/ubuntu/maverick/webkit/maverick

« back to all changes in this revision

Viewing changes to WebKit/win/DOMEventsClasses.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mike Hommey
  • Date: 2007-08-19 15:54:12 UTC
  • Revision ID: james.westby@ubuntu.com-20070819155412-uxxg1h9plpghmtbi
Tags: upstream-0~svn25144
Import upstream version 0~svn25144

Show diffs side-by-side

added added

removed removed

Lines of Context:
WebKit/win/DOMEventsClasses.cpp
 
1
/*
 
2
 * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
 
3
 *
 
4
 * Redistribution and use in source and binary forms, with or without
 
5
 * modification, are permitted provided that the following conditions
 
6
 * are met:
 
7
 * 1. Redistributions of source code must retain the above copyright
 
8
 *    notice, this list of conditions and the following disclaimer.
 
9
 * 2. Redistributions in binary form must reproduce the above copyright
 
10
 *    notice, this list of conditions and the following disclaimer in the
 
11
 *    documentation and/or other materials provided with the distribution.
 
12
 *
 
13
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 
14
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
15
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
16
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 
17
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
18
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
19
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
20
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
21
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
22
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
23
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
24
 */
 
25
 
 
26
#include "config.h"
 
27
#include "WebKitDLL.h"
 
28
#include <initguid.h>
 
29
#include "DOMEventsClasses.h"
 
30
 
 
31
#pragma warning( push, 0 )
 
32
#include <WebCore/DOMWindow.h>
 
33
#include <WebCore/Event.h>
 
34
#include <WebCore/KeyboardEvent.h>
 
35
#include <WebCore/MouseEvent.h>
 
36
#pragma warning( pop )
 
37
 
 
38
// DOMEventListener -----------------------------------------------------------
 
39
 
 
40
HRESULT STDMETHODCALLTYPE DOMEventListener::QueryInterface(const IID &riid, void** ppvObject)
 
41
{
 
42
    *ppvObject = 0;
 
43
    if (IsEqualGUID(riid, IID_IDOMEventListener))
 
44
        *ppvObject = static_cast<IDOMEventListener*>(this);
 
45
    else
 
46
        return DOMObject::QueryInterface(riid, ppvObject);
 
47
 
 
48
    AddRef();
 
49
    return S_OK;
 
50
}
 
51
 
 
52
HRESULT STDMETHODCALLTYPE DOMEventListener::handleEvent( 
 
53
    /* [in] */ IDOMEvent* /*evt*/)
 
54
{
 
55
    return E_NOTIMPL;
 
56
}
 
57
 
 
58
// DOMEvent -------------------------------------------------------------------
 
59
 
 
60
DOMEvent::DOMEvent(PassRefPtr<WebCore::Event> e)
 
61
: m_event(0)
 
62
{
 
63
    m_event = e;
 
64
}
 
65
 
 
66
DOMEvent::~DOMEvent()
 
67
{
 
68
}
 
69
 
 
70
IDOMEvent* DOMEvent::createInstance(PassRefPtr<WebCore::Event> e)
 
71
{
 
72
    if (!e)
 
73
        return 0;
 
74
 
 
75
    HRESULT hr;
 
76
    IDOMEvent* domEvent = 0;
 
77
 
 
78
    if (e->isKeyboardEvent()) {
 
79
        DOMKeyboardEvent* newEvent = new DOMKeyboardEvent(e);
 
80
        hr = newEvent->QueryInterface(IID_IDOMKeyboardEvent, (void**)&domEvent);
 
81
    } else if (e->isMouseEvent()) {
 
82
        DOMMouseEvent* newEvent = new DOMMouseEvent(e);
 
83
        hr = newEvent->QueryInterface(IID_IDOMMouseEvent, (void**)&domEvent);
 
84
    } else if (e->isMutationEvent()) {
 
85
        DOMMutationEvent* newEvent = new DOMMutationEvent(e);
 
86
        hr = newEvent->QueryInterface(IID_IDOMMutationEvent, (void**)&domEvent);
 
87
    } else if (e->isOverflowEvent()) {
 
88
        DOMOverflowEvent* newEvent = new DOMOverflowEvent(e);
 
89
        hr = newEvent->QueryInterface(IID_IDOMOverflowEvent, (void**)&domEvent);
 
90
    } else if (e->isWheelEvent()) {
 
91
        DOMWheelEvent* newEvent = new DOMWheelEvent(e);
 
92
        hr = newEvent->QueryInterface(IID_IDOMWheelEvent, (void**)&domEvent);
 
93
    } else if (e->isUIEvent()) {
 
94
        DOMUIEvent* newEvent = new DOMUIEvent(e);
 
95
        hr = newEvent->QueryInterface(IID_IDOMUIEvent, (void**)&domEvent);
 
96
    } else {
 
97
        DOMEvent* newEvent = new DOMEvent(e);
 
98
        hr = newEvent->QueryInterface(IID_IDOMEvent, (void**)&domEvent);
 
99
    }
 
100
 
 
101
    if (FAILED(hr))
 
102
        return 0;
 
103
 
 
104
    return domEvent;
 
105
}
 
106
 
 
107
HRESULT STDMETHODCALLTYPE DOMEvent::QueryInterface(const IID &riid, void** ppvObject)
 
108
{
 
109
    *ppvObject = 0;
 
110
    if (IsEqualGUID(riid, IID_DOMEvent))
 
111
        *ppvObject = this;
 
112
    else if (IsEqualGUID(riid, IID_IDOMEvent))
 
113
        *ppvObject = static_cast<IDOMEvent*>(this);
 
114
    else
 
115
        return DOMObject::QueryInterface(riid, ppvObject);
 
116
 
 
117
    AddRef();
 
118
    return S_OK;
 
119
}
 
120
 
 
121
HRESULT STDMETHODCALLTYPE DOMEvent::type( 
 
122
    /* [retval][out] */ BSTR* /*result*/)
 
123
{
 
124
    return E_NOTIMPL;
 
125
}
 
126
 
 
127
HRESULT STDMETHODCALLTYPE DOMEvent::target( 
 
128
    /* [retval][out] */ IDOMEventTarget** /*result*/)
 
129
{
 
130
    return E_NOTIMPL;
 
131
}
 
132
 
 
133
HRESULT STDMETHODCALLTYPE DOMEvent::currentTarget( 
 
134
    /* [retval][out] */ IDOMEventTarget** /*result*/)
 
135
{
 
136
    return E_NOTIMPL;
 
137
}
 
138
 
 
139
HRESULT STDMETHODCALLTYPE DOMEvent::eventPhase( 
 
140
    /* [retval][out] */ unsigned short* /*result*/)
 
141
{
 
142
    return E_NOTIMPL;
 
143
}
 
144
 
 
145
HRESULT STDMETHODCALLTYPE DOMEvent::bubbles( 
 
146
    /* [retval][out] */ BOOL* /*result*/)
 
147
{
 
148
    return E_NOTIMPL;
 
149
}
 
150
 
 
151
HRESULT STDMETHODCALLTYPE DOMEvent::cancelable( 
 
152
    /* [retval][out] */ BOOL* /*result*/)
 
153
{
 
154
    return E_NOTIMPL;
 
155
}
 
156
 
 
157
HRESULT STDMETHODCALLTYPE DOMEvent::timeStamp( 
 
158
    /* [retval][out] */ DOMTimeStamp* /*result*/)
 
159
{
 
160
    return E_NOTIMPL;
 
161
}
 
162
 
 
163
HRESULT STDMETHODCALLTYPE DOMEvent::stopPropagation( void)
 
164
{
 
165
    return E_NOTIMPL;
 
166
}
 
167
 
 
168
HRESULT STDMETHODCALLTYPE DOMEvent::preventDefault( void)
 
169
{
 
170
    return E_NOTIMPL;
 
171
}
 
172
 
 
173
HRESULT STDMETHODCALLTYPE DOMEvent::initEvent( 
 
174
    /* [in] */ BSTR /*eventTypeArg*/,
 
175
    /* [in] */ BOOL /*canBubbleArg*/,
 
176
    /* [in] */ BOOL /*cancelableArg*/)
 
177
{
 
178
    return E_NOTIMPL;
 
179
}
 
180
 
 
181
// DOMUIEvent -----------------------------------------------------------------
 
182
 
 
183
HRESULT STDMETHODCALLTYPE DOMUIEvent::QueryInterface(REFIID riid, void** ppvObject)
 
184
{
 
185
    *ppvObject = 0;
 
186
    if (IsEqualGUID(riid, IID_IDOMUIEvent))
 
187
        *ppvObject = static_cast<IDOMUIEvent*>(this);
 
188
    else
 
189
        return DOMEvent::QueryInterface(riid, ppvObject);
 
190
 
 
191
    AddRef();
 
192
    return S_OK;
 
193
}
 
194
 
 
195
HRESULT STDMETHODCALLTYPE DOMUIEvent::view( 
 
196
    /* [retval][out] */ IDOMWindow** /*result*/)
 
197
{
 
198
    return E_NOTIMPL;
 
199
}
 
200
 
 
201
HRESULT STDMETHODCALLTYPE DOMUIEvent::detail( 
 
202
    /* [retval][out] */ long* /*result*/)
 
203
{
 
204
    return E_NOTIMPL;
 
205
}
 
206
 
 
207
HRESULT STDMETHODCALLTYPE DOMUIEvent::initUIEvent( 
 
208
    /* [in] */ BSTR /*type*/,
 
209
    /* [in] */ BOOL /*canBubble*/,
 
210
    /* [in] */ BOOL /*cancelable*/,
 
211
    /* [in] */ IDOMWindow* /*view*/,
 
212
    /* [in] */ long /*detail*/)
 
213
{
 
214
    return E_NOTIMPL;
 
215
}
 
216
 
 
217
HRESULT STDMETHODCALLTYPE DOMUIEvent::keyCode( 
 
218
    /* [retval][out] */ long* /*result*/)
 
219
{
 
220
    return E_NOTIMPL;
 
221
}
 
222
 
 
223
HRESULT STDMETHODCALLTYPE DOMUIEvent::charCode( 
 
224
    /* [retval][out] */ long* /*result*/)
 
225
{
 
226
    return E_NOTIMPL;
 
227
}
 
228
 
 
229
HRESULT STDMETHODCALLTYPE DOMUIEvent::layerX( 
 
230
    /* [retval][out] */ long* /*result*/)
 
231
{
 
232
    return E_NOTIMPL;
 
233
}
 
234
 
 
235
HRESULT STDMETHODCALLTYPE DOMUIEvent::layerY( 
 
236
    /* [retval][out] */ long* /*result*/)
 
237
{
 
238
    return E_NOTIMPL;
 
239
}
 
240
 
 
241
HRESULT STDMETHODCALLTYPE DOMUIEvent::pageX( 
 
242
    /* [retval][out] */ long* /*result*/)
 
243
{
 
244
    return E_NOTIMPL;
 
245
}
 
246
 
 
247
HRESULT STDMETHODCALLTYPE DOMUIEvent::pageY( 
 
248
    /* [retval][out] */ long* /*result*/)
 
249
{
 
250
    return E_NOTIMPL;
 
251
}
 
252
 
 
253
HRESULT STDMETHODCALLTYPE DOMUIEvent::which( 
 
254
    /* [retval][out] */ long* /*result*/)
 
255
{
 
256
    return E_NOTIMPL;
 
257
}
 
258
 
 
259
// DOMKeyboardEvent -----------------------------------------------------------
 
260
 
 
261
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::QueryInterface(REFIID riid, void** ppvObject)
 
262
{
 
263
    *ppvObject = 0;
 
264
    if (IsEqualGUID(riid, IID_IDOMKeyboardEvent))
 
265
        *ppvObject = static_cast<IDOMKeyboardEvent*>(this);
 
266
    else
 
267
        return DOMUIEvent::QueryInterface(riid, ppvObject);
 
268
 
 
269
    AddRef();
 
270
    return S_OK;
 
271
}
 
272
 
 
273
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::keyIdentifier( 
 
274
    /* [retval][out] */ BSTR* /*result*/)
 
275
{
 
276
    return E_NOTIMPL;
 
277
}
 
278
 
 
279
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::keyLocation( 
 
280
    /* [retval][out] */ unsigned long* /*result*/)
 
281
{
 
282
    return E_NOTIMPL;
 
283
}
 
284
 
 
285
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::ctrlKey( 
 
286
    /* [retval][out] */ BOOL* result)
 
287
{
 
288
    *result = FALSE;
 
289
    if (!m_event || !m_event->isKeyboardEvent())
 
290
        return E_FAIL;
 
291
    WebCore::KeyboardEvent* keyEvent = static_cast<WebCore::KeyboardEvent*>(m_event.get());
 
292
 
 
293
    *result = keyEvent->ctrlKey() ? TRUE : FALSE;
 
294
    return S_OK;
 
295
}
 
296
 
 
297
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::shiftKey( 
 
298
    /* [retval][out] */ BOOL* result)
 
299
{
 
300
    *result = FALSE;
 
301
    if (!m_event || !m_event->isKeyboardEvent())
 
302
        return E_FAIL;
 
303
    WebCore::KeyboardEvent* keyEvent = static_cast<WebCore::KeyboardEvent*>(m_event.get());
 
304
 
 
305
    *result = keyEvent->shiftKey() ? TRUE : FALSE;
 
306
    return S_OK;
 
307
}
 
308
 
 
309
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::altKey( 
 
310
    /* [retval][out] */ BOOL* result)
 
311
{
 
312
    *result = FALSE;
 
313
    if (!m_event || !m_event->isKeyboardEvent())
 
314
        return E_FAIL;
 
315
    WebCore::KeyboardEvent* keyEvent = static_cast<WebCore::KeyboardEvent*>(m_event.get());
 
316
 
 
317
    *result = keyEvent->altKey() ? TRUE : FALSE;
 
318
    return S_OK;
 
319
}
 
320
 
 
321
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::metaKey( 
 
322
    /* [retval][out] */ BOOL* result)
 
323
{
 
324
    *result = FALSE;
 
325
    if (!m_event || !m_event->isKeyboardEvent())
 
326
        return E_FAIL;
 
327
    WebCore::KeyboardEvent* keyEvent = static_cast<WebCore::KeyboardEvent*>(m_event.get());
 
328
 
 
329
    *result = keyEvent->metaKey() ? TRUE : FALSE;
 
330
    return S_OK;
 
331
}
 
332
 
 
333
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::altGraphKey( 
 
334
    /* [retval][out] */ BOOL* result)
 
335
{
 
336
    *result = FALSE;
 
337
    if (!m_event || !m_event->isKeyboardEvent())
 
338
        return E_FAIL;
 
339
    WebCore::KeyboardEvent* keyEvent = static_cast<WebCore::KeyboardEvent*>(m_event.get());
 
340
 
 
341
    *result = keyEvent->altGraphKey() ? TRUE : FALSE;
 
342
    return S_OK;
 
343
}
 
344
 
 
345
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::getModifierState( 
 
346
    /* [in] */ BSTR /*keyIdentifierArg*/,
 
347
    /* [retval][out] */ BOOL* /*result*/)
 
348
{
 
349
    return E_NOTIMPL;
 
350
}
 
351
 
 
352
HRESULT STDMETHODCALLTYPE DOMKeyboardEvent::initKeyboardEvent( 
 
353
    /* [in] */ BSTR /*type*/,
 
354
    /* [in] */ BOOL /*canBubble*/,
 
355
    /* [in] */ BOOL /*cancelable*/,
 
356
    /* [in] */ IDOMWindow* /*view*/,
 
357
    /* [in] */ BSTR /*keyIdentifier*/,
 
358
    /* [in] */ unsigned long /*keyLocation*/,
 
359
    /* [in] */ BOOL /*ctrlKey*/,
 
360
    /* [in] */ BOOL /*altKey*/,
 
361
    /* [in] */ BOOL /*shiftKey*/,
 
362
    /* [in] */ BOOL /*metaKey*/,
 
363
    /* [in] */ BOOL /*graphKey*/)
 
364
{
 
365
    return E_NOTIMPL;
 
366
}
 
367
 
 
368
// DOMMouseEvent --------------------------------------------------------------
 
369
 
 
370
HRESULT STDMETHODCALLTYPE DOMMouseEvent::QueryInterface(REFIID riid, void** ppvObject)
 
371
{
 
372
    *ppvObject = 0;
 
373
    if (IsEqualGUID(riid, IID_IDOMMouseEvent))
 
374
        *ppvObject = static_cast<IDOMMouseEvent*>(this);
 
375
    else
 
376
        return DOMUIEvent::QueryInterface(riid, ppvObject);
 
377
 
 
378
    AddRef();
 
379
    return S_OK;
 
380
}
 
381
 
 
382
HRESULT STDMETHODCALLTYPE DOMMouseEvent::screenX( 
 
383
    /* [retval][out] */ long* /*result*/)
 
384
{
 
385
    return E_NOTIMPL;
 
386
}
 
387
 
 
388
HRESULT STDMETHODCALLTYPE DOMMouseEvent::screenY( 
 
389
    /* [retval][out] */ long* /*result*/)
 
390
{
 
391
    return E_NOTIMPL;
 
392
}
 
393
 
 
394
HRESULT STDMETHODCALLTYPE DOMMouseEvent::clientX( 
 
395
    /* [retval][out] */ long* /*result*/)
 
396
{
 
397
    return E_NOTIMPL;
 
398
}
 
399
 
 
400
HRESULT STDMETHODCALLTYPE DOMMouseEvent::clientY( 
 
401
    /* [retval][out] */ long* /*result*/)
 
402
{
 
403
    return E_NOTIMPL;
 
404
}
 
405
 
 
406
HRESULT STDMETHODCALLTYPE DOMMouseEvent::ctrlKey( 
 
407
    /* [retval][out] */ BOOL* result)
 
408
{
 
409
    *result = FALSE;
 
410
    if (!m_event || !m_event->isMouseEvent())
 
411
        return E_FAIL;
 
412
    WebCore::MouseEvent* mouseEvent = static_cast<WebCore::MouseEvent*>(m_event.get());
 
413
 
 
414
    *result = mouseEvent->ctrlKey() ? TRUE : FALSE;
 
415
    return S_OK;
 
416
}
 
417
 
 
418
HRESULT STDMETHODCALLTYPE DOMMouseEvent::shiftKey( 
 
419
    /* [retval][out] */ BOOL* result)
 
420
{
 
421
    *result = FALSE;
 
422
    if (!m_event || !m_event->isMouseEvent())
 
423
        return E_FAIL;
 
424
    WebCore::MouseEvent* mouseEvent = static_cast<WebCore::MouseEvent*>(m_event.get());
 
425
 
 
426
    *result = mouseEvent->shiftKey() ? TRUE : FALSE;
 
427
    return S_OK;
 
428
}
 
429
 
 
430
HRESULT STDMETHODCALLTYPE DOMMouseEvent::altKey( 
 
431
    /* [retval][out] */ BOOL* result)
 
432
{
 
433
    *result = FALSE;
 
434
    if (!m_event || !m_event->isMouseEvent())
 
435
        return E_FAIL;
 
436
    WebCore::MouseEvent* mouseEvent = static_cast<WebCore::MouseEvent*>(m_event.get());
 
437
 
 
438
    *result = mouseEvent->altKey() ? TRUE : FALSE;
 
439
    return S_OK;
 
440
}
 
441
 
 
442
HRESULT STDMETHODCALLTYPE DOMMouseEvent::metaKey( 
 
443
    /* [retval][out] */ BOOL* result)
 
444
{
 
445
    *result = FALSE;
 
446
    if (!m_event || !m_event->isMouseEvent())
 
447
        return E_FAIL;
 
448
    WebCore::MouseEvent* mouseEvent = static_cast<WebCore::MouseEvent*>(m_event.get());
 
449
 
 
450
    *result = mouseEvent->metaKey() ? TRUE : FALSE;
 
451
    return S_OK;
 
452
}
 
453
 
 
454
HRESULT STDMETHODCALLTYPE DOMMouseEvent::button( 
 
455
    /* [retval][out] */ unsigned short* /*result*/)
 
456
{
 
457
    return E_NOTIMPL;
 
458
}
 
459
 
 
460
HRESULT STDMETHODCALLTYPE DOMMouseEvent::relatedTarget( 
 
461
    /* [retval][out] */ IDOMEventTarget** /*result*/)
 
462
{
 
463
    return E_NOTIMPL;
 
464
}
 
465
 
 
466
HRESULT STDMETHODCALLTYPE DOMMouseEvent::initMouseEvent( 
 
467
    /* [in] */ BSTR /*type*/,
 
468
    /* [in] */ BOOL /*canBubble*/,
 
469
    /* [in] */ BOOL /*cancelable*/,
 
470
    /* [in] */ IDOMWindow* /*view*/,
 
471
    /* [in] */ long /*detail*/,
 
472
    /* [in] */ long /*screenX*/,
 
473
    /* [in] */ long /*screenY*/,
 
474
    /* [in] */ long /*clientX*/,
 
475
    /* [in] */ long /*clientY*/,
 
476
    /* [in] */ BOOL /*ctrlKey*/,
 
477
    /* [in] */ BOOL /*altKey*/,
 
478
    /* [in] */ BOOL /*shiftKey*/,
 
479
    /* [in] */ BOOL /*metaKey*/,
 
480
    /* [in] */ unsigned short /*button*/,
 
481
    /* [in] */ IDOMEventTarget* /*relatedTarget*/)
 
482
{
 
483
    return E_NOTIMPL;
 
484
}
 
485
 
 
486
HRESULT STDMETHODCALLTYPE DOMMouseEvent::offsetX( 
 
487
    /* [retval][out] */ long* /*result*/)
 
488
{
 
489
    return E_NOTIMPL;
 
490
}
 
491
 
 
492
HRESULT STDMETHODCALLTYPE DOMMouseEvent::offsetY( 
 
493
    /* [retval][out] */ long* /*result*/)
 
494
{
 
495
    return E_NOTIMPL;
 
496
}
 
497
 
 
498
HRESULT STDMETHODCALLTYPE DOMMouseEvent::x( 
 
499
    /* [retval][out] */ long* /*result*/)
 
500
{
 
501
    return E_NOTIMPL;
 
502
}
 
503
 
 
504
HRESULT STDMETHODCALLTYPE DOMMouseEvent::y( 
 
505
    /* [retval][out] */ long* /*result*/)
 
506
{
 
507
    return E_NOTIMPL;
 
508
}
 
509
 
 
510
HRESULT STDMETHODCALLTYPE DOMMouseEvent::fromElement( 
 
511
    /* [retval][out] */ IDOMNode** /*result*/)
 
512
{
 
513
    return E_NOTIMPL;
 
514
}
 
515
 
 
516
HRESULT STDMETHODCALLTYPE DOMMouseEvent::toElement( 
 
517
    /* [retval][out] */ IDOMNode** /*result*/)
 
518
{
 
519
    return E_NOTIMPL;
 
520
}
 
521
 
 
522
// DOMMutationEvent -----------------------------------------------------------
 
523
 
 
524
HRESULT STDMETHODCALLTYPE DOMMutationEvent::QueryInterface(REFIID riid, void** ppvObject)
 
525
{
 
526
    *ppvObject = 0;
 
527
    if (IsEqualGUID(riid, IID_IDOMMutationEvent))
 
528
        *ppvObject = static_cast<IDOMMutationEvent*>(this);
 
529
    else
 
530
        return DOMEvent::QueryInterface(riid, ppvObject);
 
531
 
 
532
    AddRef();
 
533
    return S_OK;
 
534
}
 
535
 
 
536
HRESULT STDMETHODCALLTYPE DOMMutationEvent::relatedNode( 
 
537
    /* [retval][out] */ IDOMNode** /*result*/)
 
538
{
 
539
    return E_NOTIMPL;
 
540
}
 
541
 
 
542
HRESULT STDMETHODCALLTYPE DOMMutationEvent::prevValue( 
 
543
    /* [retval][out] */ BSTR* /*result*/)
 
544
{
 
545
    return E_NOTIMPL;
 
546
}
 
547
 
 
548
HRESULT STDMETHODCALLTYPE DOMMutationEvent::newValue( 
 
549
    /* [retval][out] */ BSTR* /*result*/)
 
550
{
 
551
    return E_NOTIMPL;
 
552
}
 
553
 
 
554
HRESULT STDMETHODCALLTYPE DOMMutationEvent::attrName( 
 
555
    /* [retval][out] */ BSTR* /*result*/)
 
556
{
 
557
    return E_NOTIMPL;
 
558
}
 
559
 
 
560
HRESULT STDMETHODCALLTYPE DOMMutationEvent::attrChange( 
 
561
    /* [retval][out] */ unsigned short* /*result*/)
 
562
{
 
563
    return E_NOTIMPL;
 
564
}
 
565
 
 
566
HRESULT STDMETHODCALLTYPE DOMMutationEvent::initMutationEvent( 
 
567
    /* [in] */ BSTR /*type*/,
 
568
    /* [in] */ BOOL /*canBubble*/,
 
569
    /* [in] */ BOOL /*cancelable*/,
 
570
    /* [in] */ IDOMNode* /*relatedNode*/,
 
571
    /* [in] */ BSTR /*prevValue*/,
 
572
    /* [in] */ BSTR /*newValue*/,
 
573
    /* [in] */ BSTR /*attrName*/,
 
574
    /* [in] */ unsigned short /*attrChange*/)
 
575
{
 
576
    return E_NOTIMPL;
 
577
}
 
578
 
 
579
// DOMOverflowEvent -----------------------------------------------------------
 
580
 
 
581
HRESULT STDMETHODCALLTYPE DOMOverflowEvent::QueryInterface(REFIID riid, void** ppvObject)
 
582
{
 
583
    *ppvObject = 0;
 
584
    if (IsEqualGUID(riid, IID_IDOMOverflowEvent))
 
585
        *ppvObject = static_cast<IDOMOverflowEvent*>(this);
 
586
    else
 
587
        return DOMEvent::QueryInterface(riid, ppvObject);
 
588
 
 
589
    AddRef();
 
590
    return S_OK;
 
591
}
 
592
 
 
593
HRESULT STDMETHODCALLTYPE DOMOverflowEvent::orient( 
 
594
    /* [retval][out] */ unsigned short* /*result*/)
 
595
{
 
596
    return E_NOTIMPL;
 
597
}
 
598
 
 
599
HRESULT STDMETHODCALLTYPE DOMOverflowEvent::horizontalOverflow( 
 
600
    /* [retval][out] */ BOOL* /*result*/)
 
601
{
 
602
    return E_NOTIMPL;
 
603
}
 
604
 
 
605
HRESULT STDMETHODCALLTYPE DOMOverflowEvent::verticalOverflow( 
 
606
    /* [retval][out] */ BOOL* /*result*/)
 
607
{
 
608
    return E_NOTIMPL;
 
609
}
 
610
 
 
611
// DOMWheelEvent --------------------------------------------------------------
 
612
 
 
613
HRESULT STDMETHODCALLTYPE DOMWheelEvent::QueryInterface(REFIID riid, void** ppvObject)
 
614
{
 
615
    *ppvObject = 0;
 
616
    if (IsEqualGUID(riid, IID_IDOMWheelEvent))
 
617
        *ppvObject = static_cast<IDOMWheelEvent*>(this);
 
618
    else
 
619
        return DOMUIEvent::QueryInterface(riid, ppvObject);
 
620
 
 
621
    AddRef();
 
622
    return S_OK;
 
623
}
 
624
 
 
625
HRESULT STDMETHODCALLTYPE DOMWheelEvent::screenX( 
 
626
    /* [retval][out] */ long* /*result*/)
 
627
{
 
628
    return E_NOTIMPL;
 
629
}
 
630
 
 
631
HRESULT STDMETHODCALLTYPE DOMWheelEvent::screenY( 
 
632
    /* [retval][out] */ long* /*result*/)
 
633
{
 
634
    return E_NOTIMPL;
 
635
}
 
636
 
 
637
HRESULT STDMETHODCALLTYPE DOMWheelEvent::clientX( 
 
638
    /* [retval][out] */ long* /*result*/)
 
639
{
 
640
    return E_NOTIMPL;
 
641
}
 
642
 
 
643
HRESULT STDMETHODCALLTYPE DOMWheelEvent::clientY( 
 
644
    /* [retval][out] */ long* /*result*/)
 
645
{
 
646
    return E_NOTIMPL;
 
647
}
 
648
 
 
649
HRESULT STDMETHODCALLTYPE DOMWheelEvent::ctrlKey( 
 
650
    /* [retval][out] */ BOOL* /*result*/)
 
651
{
 
652
    return E_NOTIMPL;
 
653
}
 
654
 
 
655
HRESULT STDMETHODCALLTYPE DOMWheelEvent::shiftKey( 
 
656
    /* [retval][out] */ BOOL* /*result*/)
 
657
{
 
658
    return E_NOTIMPL;
 
659
}
 
660
 
 
661
HRESULT STDMETHODCALLTYPE DOMWheelEvent::altKey( 
 
662
    /* [retval][out] */ BOOL* /*result*/)
 
663
{
 
664
    return E_NOTIMPL;
 
665
}
 
666
 
 
667
HRESULT STDMETHODCALLTYPE DOMWheelEvent::metaKey( 
 
668
    /* [retval][out] */ BOOL* /*result*/)
 
669
{
 
670
    return E_NOTIMPL;
 
671
}
 
672
 
 
673
HRESULT STDMETHODCALLTYPE DOMWheelEvent::wheelDelta( 
 
674
    /* [retval][out] */ long* /*result*/)
 
675
{
 
676
    return E_NOTIMPL;
 
677
}
 
678
 
 
679
HRESULT STDMETHODCALLTYPE DOMWheelEvent::wheelDeltaX( 
 
680
    /* [retval][out] */ long* /*result*/)
 
681
{
 
682
    return E_NOTIMPL;
 
683
}
 
684
 
 
685
HRESULT STDMETHODCALLTYPE DOMWheelEvent::wheelDeltaY( 
 
686
    /* [retval][out] */ long* /*result*/)
 
687
{
 
688
    return E_NOTIMPL;
 
689
}
 
690
 
 
691
HRESULT STDMETHODCALLTYPE DOMWheelEvent::offsetX( 
 
692
    /* [retval][out] */ long* /*result*/)
 
693
{
 
694
    return E_NOTIMPL;
 
695
}
 
696
 
 
697
HRESULT STDMETHODCALLTYPE DOMWheelEvent::offsetY( 
 
698
    /* [retval][out] */ long* /*result*/)
 
699
{
 
700
    return E_NOTIMPL;
 
701
}
 
702
 
 
703
HRESULT STDMETHODCALLTYPE DOMWheelEvent::x( 
 
704
    /* [retval][out] */ long* /*result*/)
 
705
{
 
706
    return E_NOTIMPL;
 
707
}
 
708
 
 
709
HRESULT STDMETHODCALLTYPE DOMWheelEvent::y( 
 
710
    /* [retval][out] */ long* /*result*/)
 
711
{
 
712
    return E_NOTIMPL;
 
713
}
 
714
 
 
715
HRESULT STDMETHODCALLTYPE DOMWheelEvent::isHorizontal( 
 
716
    /* [retval][out] */ BOOL* /*result*/)
 
717
{
 
718
    return E_NOTIMPL;
 
719
}
 
720
 
 
721
HRESULT STDMETHODCALLTYPE DOMWheelEvent::initWheelEvent( 
 
722
    /* [in] */ long /*wheelDeltaX*/,
 
723
    /* [in] */ long /*wheelDeltaY*/,
 
724
    /* [in] */ IDOMWindow* /*view*/,
 
725
    /* [in] */ long /*screenX*/,
 
726
    /* [in] */ long /*screenY*/,
 
727
    /* [in] */ long /*clientX*/,
 
728
    /* [in] */ long /*clientY*/,
 
729
    /* [in] */ BOOL /*ctrlKey*/,
 
730
    /* [in] */ BOOL /*altKey*/,
 
731
    /* [in] */ BOOL /*shiftKey*/,
 
732
    /* [in] */ BOOL /*metaKey*/)
 
733
{
 
734
    return E_NOTIMPL;
 
735
}