Changeset 65633 in webkit


Ignore:
Timestamp:
Aug 18, 2010 3:05:52 PM (14 years ago)
Author:
jcivelli@chromium.org
Message:

2010-08-18 Jay Civelli <​jcivelli@chromium.org>

Reviewed by Darin Fisher.

Renaming the WebEvent to WebDOMEvent and adding a new event class
for mouse events so that the event listener API can be used to listen
to them. The renaming is needed as there already is a WebMouseEvent class.
​https://bugs.webkit.org/show_bug.cgi?id=43453

  • WebKit.gyp:
  • public/WebDOMEvent.h: Added.
  • public/WebDOMEventListener.h: Added.
  • public/WebDOMMouseEvent.h: Added.
  • public/WebDOMMutationEvent.h: Added.
  • public/WebNode.h:
  • src/EventListenerWrapper.cpp:
  • src/EventListenerWrapper.h:
  • src/WebDOMEvent.cpp: Added.
  • src/WebDOMEventListener.cpp: Added.
  • src/WebDOMEventListenerPrivate.cpp: Added.
  • src/WebDOMEventListenerPrivate.h: Added.
  • src/WebDOMMouseEvent.cpp: Added.
  • src/WebDOMMutationEvent.cpp: Added.
  • src/WebNode.cpp: (WebKit::WebNode::isElementNode): (WebKit::WebNode::addDOMEventListener): (WebKit::WebNode::removeDOMEventListener):
Location:
trunk/WebKit/chromium
Files:
2 added
10 edited
8 copied

Legend:

Unmodified
Added
Removed

  • trunk/WebKit/chromium/ChangeLog

    r65608 r65633  
     12010-08-18  Jay Civelli  <jcivelli@chromium.org>
     2
     3        Reviewed by Darin Fisher.
     4
     5        Renaming the WebEvent to WebDOMEvent and adding a new event class
     6        for mouse events so that the event listener API can be used to listen
     7        to them.  The renaming is needed as there already is a WebMouseEvent class.
     8        https://bugs.webkit.org/show_bug.cgi?id=43453
     9
     10        * WebKit.gyp:
     11        * public/WebDOMEvent.h: Added.
     12        * public/WebDOMEventListener.h: Added.
     13        * public/WebDOMMouseEvent.h: Added.
     14        * public/WebDOMMutationEvent.h: Added.
     15        * public/WebNode.h:
     16        * src/EventListenerWrapper.cpp:
     17        * src/EventListenerWrapper.h:
     18        * src/WebDOMEvent.cpp: Added.
     19        * src/WebDOMEventListener.cpp: Added.
     20        * src/WebDOMEventListenerPrivate.cpp: Added.
     21        * src/WebDOMEventListenerPrivate.h: Added.
     22        * src/WebDOMMouseEvent.cpp: Added.
     23        * src/WebDOMMutationEvent.cpp: Added.
     24        * src/WebNode.cpp:
     25        (WebKit::WebNode::isElementNode):
     26        (WebKit::WebNode::addDOMEventListener):
     27        (WebKit::WebNode::removeDOMEventListener):
     28
    1292010-08-17  Ilya Tikhonovsky  <loislo@chromium.org>
    230

  • trunk/WebKit/chromium/WebKit.gyp

    r65608 r65633  
    135135                'public/WebCString.h',
    136136                'public/WebCursorInfo.h',
     137                'public/WebDOMEvent.h',
     138                'public/WebDOMEventListener.h',
     139                'public/WebDOMMouseEvent.h',
     140                'public/WebDOMMutationEvent.h',
    137141                'public/WebDOMStringList.h',
    138142                'public/WebData.h',
    … …  
    382386                'src/WebCString.cpp',
    383387                'src/WebCursorInfo.cpp',
     388                'src/WebDOMEvent.cpp',
     389                'src/WebDOMEventListener.cpp',
     390                'src/WebDOMEventListenerPrivate.cpp',
     391                'src/WebDOMEventListenerPrivate.h',
     392                'src/WebDOMMouseEvent.cpp',
     393                'src/WebDOMMutationEvent.cpp',
    384394                'src/WebDOMStringList.cpp',
    385395                'src/WebData.cpp',

  • trunk/WebKit/chromium/public/WebDOMEventListener.h

    r65632 r65633  
    2929 */
    3030
    31 #ifndef WebEventListener_h
    32 #define WebEventListener_h
     31#ifndef WebDOMEventListener_h
     32#define WebDOMEventListener_h
    3333
    3434#include "WebCommon.h"
    … …  
    4141
    4242class EventListenerWrapper;
    43 class WebEvent;
    44 class WebEventListenerPrivate;
     43class WebDOMEvent;
     44class WebDOMEventListenerPrivate;
    4545class WebNode;
    4646class WebString;
    4747
    48 class WebEventListener {
     48class WebDOMEventListener {
    4949public:
    50     WEBKIT_API WebEventListener();
    51     WEBKIT_API virtual ~WebEventListener();
     50    WEBKIT_API WebDOMEventListener();
     51    WEBKIT_API virtual ~WebDOMEventListener();
    5252
    5353    // Called when an event is received.
    54     virtual void handleEvent(const WebEvent&) = 0;
     54    virtual void handleEvent(const WebDOMEvent&) = 0;
    5555
    5656#if WEBKIT_IMPLEMENTATION
    … …  
    6161
    6262private:
    63     WebEventListenerPrivate* m_private;
     63    WebDOMEventListenerPrivate* m_private;
    6464};
    6565

  • trunk/WebKit/chromium/public/WebDOMMouseEvent.h

    r65632 r65633  
    2828 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929 */
     30#ifndef WebDOMMouseEvent_h
     31#define WebDOMMouseEvent_h
    3032
    31 #ifndef EventListenerWrapper_h
    32 #define EventListenerWrapper_h
     33#include "WebDOMEvent.h"
    3334
    34 #include "EventListener.h"
    35 
    36 namespace WebCore {
    37 class ScriptExecutionContext;
    38 }
    39 
    40 using namespace WebCore;
     35#if WEBKIT_IMPLEMENTATION
     36namespace WebCore { class Event; }
     37#endif
    4138
    4239namespace WebKit {
    4340
    44 class WebEventListener;
     41class WebDOMMouseEvent : public WebDOMEvent {
     42public:
     43    WEBKIT_API int screenX() const;
     44    WEBKIT_API int screenY() const;
     45    WEBKIT_API int clientX() const;
     46    WEBKIT_API int clientY() const;
     47    WEBKIT_API int layerX() const;
     48    WEBKIT_API int layerY() const;
     49    WEBKIT_API int offsetX() const;
     50    WEBKIT_API int offsetY() const;
     51    WEBKIT_API int pageX() const;
     52    WEBKIT_API int pageY() const;
     53    WEBKIT_API int x() const;
     54    WEBKIT_API int y() const;
    4555
    46 class EventListenerWrapper : public EventListener {
    47 public:
    48     EventListenerWrapper(WebEventListener*);
    49     ~EventListenerWrapper();
    50 
    51     virtual bool operator==(const EventListener&);
    52     virtual void handleEvent(ScriptExecutionContext*, Event*);
    53 
    54     void webEventListenerDeleted();
    55 
    56 private:
    57     WebEventListener* m_webEventListener;
     56    WEBKIT_API int button() const;
     57    WEBKIT_API bool buttonDown() const;
    5858};
    5959

  • trunk/WebKit/chromium/public/WebDOMMutationEvent.h

    r65632 r65633  
    2828 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2929 */
     30#ifndef WebDOMMutationEvent_h
     31#define WebDOMMutationEvent_h
    3032
    31 #ifndef EventListenerWrapper_h
    32 #define EventListenerWrapper_h
     33#include "WebDOMEvent.h"
    3334
    34 #include "EventListener.h"
    35 
    36 namespace WebCore {
    37 class ScriptExecutionContext;
    38 }
    39 
    40 using namespace WebCore;
     35#if WEBKIT_IMPLEMENTATION
     36namespace WebCore { class Event; }
     37#endif
    4138
    4239namespace WebKit {
    4340
    44 class WebEventListener;
     41class WebDOMMutationEvent : public WebDOMEvent {
     42public:
     43    enum AttrChangeType {
     44        Modification    = 1,
     45        Addition        = 2,
     46        Removal         = 3
     47    };
    4548
    46 class EventListenerWrapper : public EventListener {
    47 public:
    48     EventListenerWrapper(WebEventListener*);
    49     ~EventListenerWrapper();
    50 
    51     virtual bool operator==(const EventListener&);
    52     virtual void handleEvent(ScriptExecutionContext*, Event*);
    53 
    54     void webEventListenerDeleted();
    55 
    56 private:
    57     WebEventListener* m_webEventListener;
     49    WEBKIT_API WebNode relatedNode() const;
     50    WEBKIT_API WebString prevValue() const;
     51    WEBKIT_API WebString newValue() const;
     52    WEBKIT_API WebString attrName() const;
     53    WEBKIT_API AttrChangeType attrChange() const;
    5854};
    5955

  • trunk/WebKit/chromium/public/WebEventListener.h

    r62133 r65633  
    4040namespace WebKit {
    4141
    42 class EventListenerWrapper;
     42class DeprecatedEventListenerWrapper;
    4343class WebEvent;
    4444class WebEventListenerPrivate;
    … …  
    5555
    5656#if WEBKIT_IMPLEMENTATION
    57     void notifyEventListenerDeleted(EventListenerWrapper*);
    58     EventListenerWrapper* createEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::Node* node);
    59     EventListenerWrapper* getEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::Node* node);
     57    void notifyEventListenerDeleted(DeprecatedEventListenerWrapper*);
     58    DeprecatedEventListenerWrapper* createEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::Node* node);
     59    DeprecatedEventListenerWrapper* getEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::Node* node);
    6060#endif
    6161

  • trunk/WebKit/chromium/public/WebNode.h

    r63160 r65633  
    3939
    4040namespace WebKit {
     41class WebDOMEventListener;
     42class WebDOMEventListenerPrivate;
    4143class WebDocument;
    4244class WebEventListener;
    … …  
    98100    WEBKIT_API bool isTextNode() const;
    99101    WEBKIT_API bool isElementNode() const;
     102    WEBKIT_API void addEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture);
     103    WEBKIT_API void removeEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture);
    100104    WEBKIT_API void addEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture);
    101105    WEBKIT_API void removeEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture);

  • trunk/WebKit/chromium/src/EventListenerWrapper.cpp

    r53934 r65633  
    3535#include "EventListener.h"
    3636
     37#include "WebDOMEvent.h"
     38#include "WebDOMEventListener.h"
    3739#include "WebEvent.h"
    3840#include "WebEventListener.h"
    … …  
    4042namespace WebKit {
    4143
    42 EventListenerWrapper::EventListenerWrapper(WebEventListener* webEventListener)
     44EventListenerWrapper::EventListenerWrapper(WebDOMEventListener* webDOMEventListener)
    4345    : EventListener(EventListener::JSEventListenerType)
    44     , m_webEventListener(webEventListener)
     46    , m_webDOMEventListener(webDOMEventListener)
    4547{
    4648}
    … …  
    4850EventListenerWrapper::~EventListenerWrapper()
    4951{
    50     if (m_webEventListener)
    51         m_webEventListener->notifyEventListenerDeleted(this);
     52    if (m_webDOMEventListener)
     53        m_webDOMEventListener->notifyEventListenerDeleted(this);
    5254}
    5355
    … …  
    5961void EventListenerWrapper::handleEvent(ScriptExecutionContext* context, Event* event)
    6062{
     63    if (!m_webDOMEventListener)
     64        return;
     65    WebDOMEvent webDOMEvent(event);
     66    m_webDOMEventListener->handleEvent(webDOMEvent);
     67}
     68
     69void EventListenerWrapper::webDOMEventListenerDeleted()
     70{
     71    m_webDOMEventListener = 0;
     72}
     73
     74DeprecatedEventListenerWrapper::DeprecatedEventListenerWrapper(WebEventListener* webEventListener)
     75    : EventListener(EventListener::JSEventListenerType)
     76    , m_webEventListener(webEventListener)
     77{
     78}
     79
     80DeprecatedEventListenerWrapper::~DeprecatedEventListenerWrapper()
     81{
     82    if (m_webEventListener)
     83        m_webEventListener->notifyEventListenerDeleted(this);
     84}
     85
     86bool DeprecatedEventListenerWrapper::operator==(const EventListener& listener)
     87{
     88    return this == &listener;
     89}
     90
     91void DeprecatedEventListenerWrapper::handleEvent(ScriptExecutionContext* context, Event* event)
     92{
    6193    if (!m_webEventListener)
    6294        return;
    … …  
    6597}
    6698
    67 void EventListenerWrapper::webEventListenerDeleted()
     99void DeprecatedEventListenerWrapper::webEventListenerDeleted()
    68100{
    69101    m_webEventListener = 0;

  • trunk/WebKit/chromium/src/EventListenerWrapper.h

    r53934 r65633  
    4242namespace WebKit {
    4343
     44class WebDOMEventListener;
    4445class WebEventListener;
    4546
     47// FIXME: Remove the DeprecatedEventListenerWrapper class below once Chromium
     48// switched to using WebDOMEvent.
    4649class EventListenerWrapper : public EventListener {
    4750public:
    48     EventListenerWrapper(WebEventListener*);
     51    EventListenerWrapper(WebDOMEventListener*);
    4952    ~EventListenerWrapper();
     53
     54    virtual bool operator==(const EventListener&);
     55    virtual void handleEvent(ScriptExecutionContext*, Event*);
     56
     57    void webDOMEventListenerDeleted();
     58
     59private:
     60    WebDOMEventListener* m_webDOMEventListener;
     61};
     62
     63class DeprecatedEventListenerWrapper : public EventListener {
     64public:
     65    DeprecatedEventListenerWrapper(WebEventListener*);
     66    ~DeprecatedEventListenerWrapper();
    5067
    5168    virtual bool operator==(const EventListener&);
    … …  
    5875};
    5976
     77
    6078} // namespace WebKit
    6179

  • trunk/WebKit/chromium/src/WebDOMEventListener.cpp

    r65632 r65633  
    3030
    3131#include "config.h"
    32 #include "WebEventListener.h"
     32#include "WebDOMEventListener.h"
    3333
    34 #include "WebEventListenerPrivate.h"
     34#include "WebDOMEventListenerPrivate.h"
    3535
    3636namespace WebKit {
    3737
    38 WebEventListener::WebEventListener()
    39     : m_private(new WebEventListenerPrivate(this))
     38WebDOMEventListener::WebDOMEventListener()
     39    : m_private(new WebDOMEventListenerPrivate(this))
    4040{
    4141}
    4242
    43 WebEventListener::~WebEventListener()
     43WebDOMEventListener::~WebDOMEventListener()
    4444{
    45     m_private->webEventListenerDeleted();
     45    m_private->webDOMEventListenerDeleted();
    4646    delete m_private;
    4747}
    4848
    49 void WebEventListener::notifyEventListenerDeleted(EventListenerWrapper* wrapper)
     49void WebDOMEventListener::notifyEventListenerDeleted(EventListenerWrapper* wrapper)
    5050{
    5151    m_private->eventListenerDeleted(wrapper);
    5252}
    5353
    54 EventListenerWrapper* WebEventListener::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     54EventListenerWrapper* WebDOMEventListener::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    5555{
    5656    return m_private->createEventListenerWrapper(eventType, useCapture, node);
    5757}
    5858
    59 EventListenerWrapper* WebEventListener::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     59EventListenerWrapper* WebDOMEventListener::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    6060{
    6161    return m_private->getEventListenerWrapper(eventType, useCapture, node);

  • trunk/WebKit/chromium/src/WebDOMEventListenerPrivate.cpp

    r65632 r65633  
    3030
    3131#include "config.h"
    32 #include "WebEventListenerPrivate.h"
     32#include "WebDOMEventListenerPrivate.h"
    3333
    3434#include "EventListenerWrapper.h"
    35 #include "WebEventListener.h"
     35#include "WebDOMEventListener.h"
    3636
    3737namespace WebKit {
    3838
    39 WebEventListenerPrivate::WebEventListenerPrivate(WebEventListener* webEventListener)
    40     : m_webEventListener(webEventListener)
     39WebDOMEventListenerPrivate::WebDOMEventListenerPrivate(WebDOMEventListener* webDOMEventListener)
     40    : m_webDOMEventListener(webDOMEventListener)
    4141{
    4242}
    4343
    44 WebEventListenerPrivate::~WebEventListenerPrivate()
     44WebDOMEventListenerPrivate::~WebDOMEventListenerPrivate()
    4545{
    4646}
    4747
    48 EventListenerWrapper* WebEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     48EventListenerWrapper* WebDOMEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    4949{
    50     EventListenerWrapper* listenerWrapper = new EventListenerWrapper(m_webEventListener);
    51     WebEventListenerPrivate::ListenerInfo listenerInfo(eventType, useCapture, listenerWrapper, node);
     50    EventListenerWrapper* listenerWrapper = new EventListenerWrapper(m_webDOMEventListener);
     51    WebDOMEventListenerPrivate::ListenerInfo listenerInfo(eventType, useCapture, listenerWrapper, node);
    5252    m_listenerWrappers.append(listenerInfo);
    5353    return listenerWrapper;
    5454}
    5555
    56 EventListenerWrapper* WebEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     56EventListenerWrapper* WebDOMEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    5757{
    58     Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter;
     58    Vector<WebDOMEventListenerPrivate::ListenerInfo>::const_iterator iter;
    5959    for (iter = m_listenerWrappers.begin(); iter != m_listenerWrappers.end(); ++iter) {
    6060        if (iter->node == node)
    … …  
    6565}
    6666
    67 void WebEventListenerPrivate::webEventListenerDeleted()
     67void WebDOMEventListenerPrivate::webDOMEventListenerDeleted()
    6868{
    69     // Notifies all WebEventListenerWrappers that we are going away so they can
     69    // Notifies all WebDOMEventListenerWrappers that we are going away so they can
    7070    // invalidate their pointer to us.
    71     Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter;
     71    Vector<WebDOMEventListenerPrivate::ListenerInfo>::const_iterator iter;
    7272    for (iter = m_listenerWrappers.begin(); iter != m_listenerWrappers.end(); ++iter)
    73         iter->eventListenerWrapper->webEventListenerDeleted();
     73        iter->eventListenerWrapper->webDOMEventListenerDeleted();
    7474}
    7575
    76 void WebEventListenerPrivate::eventListenerDeleted(EventListenerWrapper* eventListener)
     76void WebDOMEventListenerPrivate::eventListenerDeleted(EventListenerWrapper* eventListener)
    7777{
    7878    for (size_t i = 0; i < m_listenerWrappers.size(); ++i) {

  • trunk/WebKit/chromium/src/WebDOMEventListenerPrivate.h

    r65632 r65633  
    2929 */
    3030
    31 #ifndef WebEventListenerPrivate_h
    32 #define WebEventListenerPrivate_h
     31#ifndef WebDOMEventListenerPrivate_h
     32#define WebDOMEventListenerPrivate_h
    3333
    3434#include "WebString.h"
    … …  
    4545
    4646class EventListenerWrapper;
    47 class WebEventListener;
     47class WebDOMEventListener;
    4848
    49 class WebEventListenerPrivate {
     49class WebDOMEventListenerPrivate {
    5050public:
    51     WebEventListenerPrivate(WebEventListener* webEventListener);
    52     ~WebEventListenerPrivate();
     51    WebDOMEventListenerPrivate(WebDOMEventListener* webDOMEventListener);
     52    ~WebDOMEventListenerPrivate();
    5353
    5454    EventListenerWrapper* createEventListenerWrapper(
    … …  
    5656
    5757    // Gets the ListenerEventWrapper for a specific node.
    58     // Used by WebNode::removeEventListener().
     58    // Used by WebNode::removeDOMEventListener().
    5959    EventListenerWrapper* getEventListenerWrapper(
    6060        const WebString& eventType, bool useCapture, Node* node);
    6161
    62     // Called by the WebEventListener when it is about to be deleted.
    63     void webEventListenerDeleted();
     62    // Called by the WebDOMEventListener when it is about to be deleted.
     63    void webDOMEventListenerDeleted();
    6464
    6565    // Called by the EventListenerWrapper when it is about to be deleted.
    … …  
    8484
    8585private:
    86     WebEventListener* m_webEventListener;
     86    WebDOMEventListener* m_webDOMEventListener;
    8787
    8888    // We keep a list of the wrapper for the WebKit EventListener, it is needed

  • trunk/WebKit/chromium/src/WebDOMMouseEvent.cpp

    r65632 r65633  
    3030
    3131#include "config.h"
    32 #include "EventListenerWrapper.h"
     32#include "WebDOMMouseEvent.h"
    3333
    34 #include "Event.h"
    35 #include "EventListener.h"
     34#include "MouseEvent.h"
    3635
    37 #include "WebEvent.h"
    38 #include "WebEventListener.h"
     36using namespace WebCore;
    3937
    4038namespace WebKit {
    4139
    42 EventListenerWrapper::EventListenerWrapper(WebEventListener* webEventListener)
    43     : EventListener(EventListener::JSEventListenerType)
    44     , m_webEventListener(webEventListener)
     40int WebDOMMouseEvent::screenX() const
    4541{
     42    return constUnwrap<MouseEvent>()->screenX();
    4643}
    4744
    48 EventListenerWrapper::~EventListenerWrapper()
     45int WebDOMMouseEvent::screenY() const
    4946{
    50     if (m_webEventListener)
    51         m_webEventListener->notifyEventListenerDeleted(this);
     47    return constUnwrap<MouseEvent>()->screenY();
    5248}
    5349
    54 bool EventListenerWrapper::operator==(const EventListener& listener)
     50int WebDOMMouseEvent::clientX() const
    5551{
    56     return this == &listener;
     52    return constUnwrap<MouseEvent>()->clientX();
    5753}
    5854
    59 void EventListenerWrapper::handleEvent(ScriptExecutionContext* context, Event* event)
     55int WebDOMMouseEvent::clientY() const
    6056{
    61     if (!m_webEventListener)
    62         return;
    63     WebEvent webEvent(event);
    64     m_webEventListener->handleEvent(webEvent);
     57    return constUnwrap<MouseEvent>()->clientY();
    6558}
    6659
    67 void EventListenerWrapper::webEventListenerDeleted()
     60int WebDOMMouseEvent::layerX() const
    6861{
    69     m_webEventListener = 0;
     62    return constUnwrap<MouseEvent>()->layerX();
     63}
     64
     65int WebDOMMouseEvent::layerY() const
     66{
     67    return constUnwrap<MouseEvent>()->layerY();
     68}
     69
     70int WebDOMMouseEvent::offsetX() const
     71{
     72    return constUnwrap<MouseEvent>()->offsetX();
     73}
     74
     75int WebDOMMouseEvent::offsetY() const
     76{
     77    return constUnwrap<MouseEvent>()->offsetY();
     78}
     79
     80int WebDOMMouseEvent::pageX() const
     81{
     82    return constUnwrap<MouseEvent>()->pageX();
     83}
     84
     85int WebDOMMouseEvent::pageY() const
     86{
     87    return constUnwrap<MouseEvent>()->pageY();
     88}
     89
     90int WebDOMMouseEvent::x() const
     91{
     92    return constUnwrap<MouseEvent>()->x();
     93}
     94
     95int WebDOMMouseEvent::y() const
     96{
     97    return constUnwrap<MouseEvent>()->y();
     98}
     99
     100int WebDOMMouseEvent::button() const
     101{
     102    return constUnwrap<MouseEvent>()->button();
     103}
     104
     105bool WebDOMMouseEvent::buttonDown() const
     106{
     107    return constUnwrap<MouseEvent>()->buttonDown();
    70108}
    71109

  • trunk/WebKit/chromium/src/WebDOMMutationEvent.cpp

    r65632 r65633  
    2929 */
    3030
    31 #ifndef EventListenerWrapper_h
    32 #define EventListenerWrapper_h
     31#include "config.h"
     32#include "WebDOMMutationEvent.h"
    3333
    34 #include "EventListener.h"
    35 
    36 namespace WebCore {
    37 class ScriptExecutionContext;
    38 }
     34#include "MutationEvent.h"
    3935
    4036using namespace WebCore;
    … …  
    4238namespace WebKit {
    4339
    44 class WebEventListener;
     40WebNode WebDOMMutationEvent::relatedNode() const
     41{
     42    return WebNode(constUnwrap<MutationEvent>()->relatedNode());
     43}
    4544
    46 class EventListenerWrapper : public EventListener {
    47 public:
    48     EventListenerWrapper(WebEventListener*);
    49     ~EventListenerWrapper();
     45WebString WebDOMMutationEvent::prevValue() const
     46{
     47    return WebString(constUnwrap<MutationEvent>()->prevValue());
     48}
    5049
    51     virtual bool operator==(const EventListener&);
    52     virtual void handleEvent(ScriptExecutionContext*, Event*);
     50WebString WebDOMMutationEvent::newValue() const
     51{
     52    return WebString(constUnwrap<MutationEvent>()->newValue());
     53}
    5354
    54     void webEventListenerDeleted();
     55WebString WebDOMMutationEvent::attrName() const
     56{
     57    return WebString(constUnwrap<MutationEvent>()->attrName());
     58}
    5559
    56 private:
    57     WebEventListener* m_webEventListener;
    58 };
     60WebDOMMutationEvent::AttrChangeType WebDOMMutationEvent::attrChange() const
     61{
     62    return static_cast<AttrChangeType>(constUnwrap<MutationEvent>()->attrChange());
     63}
    5964
    6065} // namespace WebKit
    61 
    62 #endif

  • trunk/WebKit/chromium/src/WebEventListener.cpp

    r53934 r65633  
    4747}
    4848
    49 void WebEventListener::notifyEventListenerDeleted(EventListenerWrapper* wrapper)
     49void WebEventListener::notifyEventListenerDeleted(DeprecatedEventListenerWrapper* wrapper)
    5050{
    5151    m_private->eventListenerDeleted(wrapper);
    5252}
    5353
    54 EventListenerWrapper* WebEventListener::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     54DeprecatedEventListenerWrapper* WebEventListener::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    5555{
    5656    return m_private->createEventListenerWrapper(eventType, useCapture, node);
    5757}
    5858
    59 EventListenerWrapper* WebEventListener::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     59DeprecatedEventListenerWrapper* WebEventListener::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    6060{
    6161    return m_private->getEventListenerWrapper(eventType, useCapture, node);

  • trunk/WebKit/chromium/src/WebEventListenerPrivate.cpp

    r53934 r65633  
    4646}
    4747
    48 EventListenerWrapper* WebEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     48DeprecatedEventListenerWrapper* WebEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    4949{
    50     EventListenerWrapper* listenerWrapper = new EventListenerWrapper(m_webEventListener);
     50    DeprecatedEventListenerWrapper* listenerWrapper = new DeprecatedEventListenerWrapper(m_webEventListener);
    5151    WebEventListenerPrivate::ListenerInfo listenerInfo(eventType, useCapture, listenerWrapper, node);
    5252    m_listenerWrappers.append(listenerInfo);
    … …  
    5454}
    5555
    56 EventListenerWrapper* WebEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
     56DeprecatedEventListenerWrapper* WebEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, bool useCapture, Node* node)
    5757{
    5858    Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter;
    … …  
    7474}
    7575
    76 void WebEventListenerPrivate::eventListenerDeleted(EventListenerWrapper* eventListener)
     76void WebEventListenerPrivate::eventListenerDeleted(DeprecatedEventListenerWrapper* eventListener)
    7777{
    7878    for (size_t i = 0; i < m_listenerWrappers.size(); ++i) {

  • trunk/WebKit/chromium/src/WebEventListenerPrivate.h

    r53934 r65633  
    4444namespace WebKit {
    4545
    46 class EventListenerWrapper;
     46class DeprecatedEventListenerWrapper;
    4747class WebEventListener;
    4848
    … …  
    5252    ~WebEventListenerPrivate();
    5353
    54     EventListenerWrapper* createEventListenerWrapper(
     54    DeprecatedEventListenerWrapper* createEventListenerWrapper(
    5555        const WebString& eventType, bool useCapture, Node* node);
    5656
    57     // Gets the ListenerEventWrapper for a specific node.
     57    // Gets the DeprecatedEventListenerWrapper for a specific node.
    5858    // Used by WebNode::removeEventListener().
    59     EventListenerWrapper* getEventListenerWrapper(
     59    DeprecatedEventListenerWrapper* getEventListenerWrapper(
    6060        const WebString& eventType, bool useCapture, Node* node);
    6161
    … …  
    6363    void webEventListenerDeleted();
    6464
    65     // Called by the EventListenerWrapper when it is about to be deleted.
    66     void eventListenerDeleted(EventListenerWrapper* eventListener);
     65    // Called by the DeprecatedEventListenerWrapper when it is about to be deleted.
     66    void eventListenerDeleted(DeprecatedEventListenerWrapper* eventListener);
    6767
    6868    struct ListenerInfo {
    6969        ListenerInfo(const WebString& eventType, bool useCapture,
    70                      EventListenerWrapper* eventListenerWrapper,
     70                     DeprecatedEventListenerWrapper* eventListenerWrapper,
    7171                     Node* node)
    7272            : eventType(eventType)
    … …  
    7979        WebString eventType;
    8080        bool useCapture;
    81         EventListenerWrapper* eventListenerWrapper;
     81        DeprecatedEventListenerWrapper* eventListenerWrapper;
    8282        Node* node;
    8383    };

  • trunk/WebKit/chromium/src/WebNode.cpp

    r63160 r65633  
    3939
    4040#include "EventListenerWrapper.h"
     41#include "WebDOMEvent.h"
     42#include "WebDOMEventListener.h"
    4143#include "WebDocument.h"
    4244#include "WebEvent.h"
    … …  
    150152}
    151153
    152 void WebNode::addEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture)
     154void WebNode::addEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture)
    153155{
    154156    EventListenerWrapper* listenerWrapper =
    … …  
    160162}
    161163
    162 void WebNode::removeEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture)
     164void WebNode::removeEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture)
    163165{
    164166    EventListenerWrapper* listenerWrapper =
    … …  
    168170}
    169171
     172void WebNode::addEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture)
     173{
     174    DeprecatedEventListenerWrapper* listenerWrapper =
     175        listener->createEventListenerWrapper(eventType, useCapture, m_private.get());
     176    // The listenerWrapper is only referenced by the actual Node.  Once it goes
     177    // away, the wrapper notifies the WebEventListener so it can clear its
     178    // pointer to it.
     179    m_private->addEventListener(eventType, adoptRef(listenerWrapper), useCapture);
     180}
     181
     182void WebNode::removeEventListener(const WebString& eventType, WebEventListener* listener, bool useCapture)
     183{
     184    DeprecatedEventListenerWrapper* listenerWrapper =
     185        listener->getEventListenerWrapper(eventType, useCapture, m_private.get());
     186    m_private->removeEventListener(eventType, listenerWrapper, useCapture);
     187    // listenerWrapper is now deleted.
     188}
     189
    170190void WebNode::simulateClick()
    171191{
Note: See TracChangeset for help on using the changeset viewer.