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 }