2009-02-02 Darin Adler <darin@apple.com>
[WebKit-https.git] / WebCore / dom / EventTargetNode.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
6  *           (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "EventTargetNode.h"
27
28 #include "Document.h"
29 #include "EventException.h"
30 #include "EventHandler.h"
31 #include "EventListener.h"
32 #include "EventNames.h"
33 #include "Frame.h"
34 #include "FrameView.h"
35 #include "KeyboardEvent.h"
36 #include "MouseEvent.h"
37 #include "MutationEvent.h"
38 #include "NodeRareData.h"
39 #include "Page.h"
40 #include "PlatformMouseEvent.h"
41 #include "PlatformWheelEvent.h"
42 #include "ProgressEvent.h"
43 #include "RegisteredEventListener.h"
44 #include "ScriptController.h"
45 #include "TextEvent.h"
46 #include "WebKitAnimationEvent.h"
47 #include "WebKitTransitionEvent.h"
48 #include "WheelEvent.h"
49 #include <wtf/HashSet.h>
50
51 #if ENABLE(DOM_STORAGE)
52 #include "StorageEvent.h"
53 #endif
54
55 #if ENABLE(SVG)
56 #include "SVGElementInstance.h"
57 #include "SVGUseElement.h"
58 #endif
59
60 namespace WebCore {
61     
62 static HashSet<EventTargetNode*>* gNodesDispatchingSimulatedClicks = 0; 
63
64 EventTargetNode::~EventTargetNode()
65 {
66     if (!eventListeners().isEmpty() && !inDocument())
67         document()->unregisterDisconnectedNodeWithEventListeners(this);
68 }
69
70 ScriptExecutionContext* EventTargetNode::scriptExecutionContext() const
71 {
72     return document();
73 }
74
75 const RegisteredEventListenerVector& EventTargetNode::eventListeners() const
76 {
77     if (hasRareData()) {
78         if (RegisteredEventListenerVector* listeners = rareData()->listeners())
79             return *listeners;
80     }
81     static const RegisteredEventListenerVector* emptyListenersVector = new RegisteredEventListenerVector;
82     return *emptyListenersVector;
83 }
84
85 void EventTargetNode::insertedIntoDocument()
86 {
87     if (!eventListeners().isEmpty())
88         document()->unregisterDisconnectedNodeWithEventListeners(this);
89
90     setInDocument(true);
91 }
92
93 void EventTargetNode::removedFromDocument()
94 {
95     if (!eventListeners().isEmpty())
96         document()->registerDisconnectedNodeWithEventListeners(this);
97
98     setInDocument(false);
99 }
100
101 void EventTargetNode::willMoveToNewOwnerDocument()
102 {
103     if (!eventListeners().isEmpty())
104         document()->unregisterDisconnectedNodeWithEventListeners(this);
105
106     Node::willMoveToNewOwnerDocument();
107 }
108
109 void EventTargetNode::didMoveToNewOwnerDocument()
110 {
111     if (!eventListeners().isEmpty())
112         document()->registerDisconnectedNodeWithEventListeners(this);
113
114     Node::didMoveToNewOwnerDocument();
115 }
116
117 static inline void updateSVGElementInstancesAfterEventListenerChange(EventTargetNode* referenceNode)
118 {
119     ASSERT(referenceNode);
120
121 #if ENABLE(SVG)
122     if (!referenceNode->isSVGElement())
123         return;
124
125     // Elements living inside a <use> shadow tree, never cause any updates!
126     if (referenceNode->shadowTreeRootNode())
127         return;
128
129     // We're possibly (a child of) an element that is referenced by a <use> client
130     // If an event listeners changes on a referenced element, update all instances.
131     for (Node* node = referenceNode; node; node = node->parentNode()) {
132         if (!node->hasID() || !node->isSVGElement())
133             continue;
134
135         SVGElementInstance::invalidateAllInstancesOfElement(static_cast<SVGElement*>(node));
136         break;
137     }
138 #endif
139 }
140
141 void EventTargetNode::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
142 {
143     Document* document = this->document();
144     if (!document->attached())
145         return;
146
147     document->addListenerTypeIfNeeded(eventType);
148
149     RegisteredEventListenerVector& listeners = ensureRareData()->ensureListeners();
150
151     // Remove existing identical listener set with identical arguments.
152     // The DOM2 spec says that "duplicate instances are discarded" in this case.
153     removeEventListener(eventType, listener.get(), useCapture);
154
155     // adding the first one
156     if (listeners.isEmpty() && !inDocument())
157         document->registerDisconnectedNodeWithEventListeners(this);
158
159     listeners.append(RegisteredEventListener::create(eventType, listener, useCapture));
160     updateSVGElementInstancesAfterEventListenerChange(this);
161 }
162
163 void EventTargetNode::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
164 {
165     if (!hasRareData())
166         return;
167
168     RegisteredEventListenerVector* listeners = rareData()->listeners();
169     if (!listeners)
170         return;
171
172     size_t size = listeners->size();
173     for (size_t i = 0; i < size; ++i) {
174         RegisteredEventListener& r = *listeners->at(i);
175         if (r.eventType() == eventType && r.listener() == listener && r.useCapture() == useCapture) {
176             r.setRemoved(true);
177             listeners->remove(i);
178
179             // removed last
180             if (listeners->isEmpty() && !inDocument())
181                 document()->unregisterDisconnectedNodeWithEventListeners(this);
182
183             updateSVGElementInstancesAfterEventListenerChange(this);
184             return;
185         }
186     }
187 }
188
189 void EventTargetNode::removeAllEventListenersSlowCase()
190 {
191     ASSERT(hasRareData());
192
193     RegisteredEventListenerVector* listeners = rareData()->listeners();
194     if (!listeners)
195         return;
196
197     size_t size = listeners->size();
198     for (size_t i = 0; i < size; ++i)
199         listeners->at(i)->setRemoved(true);
200     listeners->clear();
201 }
202
203 void EventTargetNode::handleLocalEvents(Event* event, bool useCapture)
204 {
205     if (disabled() && event->isMouseEvent())
206         return;
207
208     RegisteredEventListenerVector listenersCopy = eventListeners();
209     size_t size = listenersCopy.size();
210     for (size_t i = 0; i < size; ++i) {
211         const RegisteredEventListener& r = *listenersCopy[i];
212         if (r.eventType() == event->type() && r.useCapture() == useCapture && !r.removed())
213             r.listener()->handleEvent(event, false);
214     }
215 }
216
217 #if ENABLE(SVG)
218 static inline SVGElementInstance* eventTargetAsSVGElementInstance(EventTargetNode* referenceNode)
219 {
220     ASSERT(referenceNode);
221     if (!referenceNode->isSVGElement())
222         return 0;
223
224     // Spec: The event handling for the non-exposed tree works as if the referenced element had been textually included
225     // as a deeply cloned child of the 'use' element, except that events are dispatched to the SVGElementInstance objects
226     for (Node* n = referenceNode; n; n = n->parentNode()) {
227         if (!n->isShadowNode() || !n->isSVGElement())
228             continue;
229
230         Node* shadowTreeParentElement = n->shadowParentNode();
231         ASSERT(shadowTreeParentElement->hasTagName(SVGNames::useTag));
232
233         if (SVGElementInstance* instance = static_cast<SVGUseElement*>(shadowTreeParentElement)->instanceForShadowTreeElement(referenceNode))
234             return instance;
235     }
236
237     return 0;
238 }
239 #endif
240
241 static inline EventTarget* eventTargetRespectingSVGTargetRules(EventTargetNode* referenceNode)
242 {
243     ASSERT(referenceNode);
244
245 #if ENABLE(SVG)
246     if (SVGElementInstance* instance = eventTargetAsSVGElementInstance(referenceNode)) {
247         ASSERT(instance->shadowTreeElement() == referenceNode);
248         return instance;
249     }
250 #endif
251
252     return referenceNode;
253 }
254
255 bool EventTargetNode::dispatchEvent(PassRefPtr<Event> e, ExceptionCode& ec)
256 {
257     RefPtr<Event> evt(e);
258     ASSERT(!eventDispatchForbidden());
259     if (!evt || evt->type().isEmpty()) { 
260         ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
261         return false;
262     }
263
264     evt->setTarget(eventTargetRespectingSVGTargetRules(this));
265
266     RefPtr<FrameView> view = document()->view();
267     return dispatchGenericEvent(evt.release());
268 }
269
270 bool EventTargetNode::dispatchGenericEvent(PassRefPtr<Event> prpEvent)
271 {
272     RefPtr<Event> event(prpEvent);
273
274     ASSERT(!eventDispatchForbidden());
275     ASSERT(event->target());
276     ASSERT(!event->type().isNull()); // JavaScript code can create an event with an empty name, but not null.
277
278     // Make a vector of ancestors to send the event to.
279     // If the node is not in a document just send the event to it.
280     // Be sure to ref all of nodes since event handlers could result in the last reference going away.
281     RefPtr<EventTargetNode> thisNode(this);
282     Vector<RefPtr<ContainerNode> > ancestors;
283     if (inDocument()) {
284         for (ContainerNode* ancestor = eventParentNode(); ancestor; ancestor = ancestor->eventParentNode()) {
285 #if ENABLE(SVG)
286             // Skip <use> shadow tree elements.
287             if (ancestor->isSVGElement() && ancestor->isShadowNode())
288                 continue;
289 #endif
290             ancestors.append(ancestor);
291         }
292     }
293
294     // Set up a pointer to indicate whether to dispatch window events.
295     // We don't dispatch load events to the window. That quirk was originally
296     // added because Mozilla doesn't propagate load events to the window object.
297     Document* documentForWindowEvents = 0;
298     if (event->type() != eventNames().loadEvent) {
299         EventTargetNode* topLevelContainer = ancestors.isEmpty() ? this : ancestors.last().get();
300         if (topLevelContainer->isDocumentNode())
301             documentForWindowEvents = static_cast<Document*>(topLevelContainer);
302     }
303
304     // Give the target node a chance to do some work before DOM event handlers get a crack.
305     void* data = preDispatchEventHandler(event.get());
306     if (event->propagationStopped())
307         goto doneDispatching;
308
309     // Trigger capturing event handlers, starting at the top and working our way down.
310     event->setEventPhase(Event::CAPTURING_PHASE);
311
312     if (documentForWindowEvents) {
313         event->setCurrentTarget(documentForWindowEvents);
314         documentForWindowEvents->handleWindowEvent(event.get(), true);
315         if (event->propagationStopped())
316             goto doneDispatching;
317     }
318     for (size_t i = ancestors.size(); i; --i) {
319         ContainerNode* ancestor = ancestors[i - 1].get();
320         event->setCurrentTarget(eventTargetRespectingSVGTargetRules(ancestor));
321         ancestor->handleLocalEvents(event.get(), true);
322         if (event->propagationStopped())
323             goto doneDispatching;
324     }
325
326     event->setEventPhase(Event::AT_TARGET);
327
328     // We do want capturing event listeners to be invoked here, even though
329     // that violates some versions of the DOM specification; Mozilla does it.
330     event->setCurrentTarget(eventTargetRespectingSVGTargetRules(this));
331     handleLocalEvents(event.get(), true);
332     if (event->propagationStopped())
333         goto doneDispatching;
334     handleLocalEvents(event.get(), false);
335     if (event->propagationStopped())
336         goto doneDispatching;
337
338     if (event->bubbles() && !event->cancelBubble()) {
339         // Trigger bubbling event handlers, starting at the bottom and working our way up.
340         event->setEventPhase(Event::BUBBLING_PHASE);
341
342         size_t size = ancestors.size();
343         for (size_t i = 0; i < size; ++i) {
344             ContainerNode* ancestor = ancestors[i].get();
345             event->setCurrentTarget(eventTargetRespectingSVGTargetRules(ancestor));
346             ancestor->handleLocalEvents(event.get(), false);
347             if (event->propagationStopped() || event->cancelBubble())
348                 goto doneDispatching;
349         }
350         if (documentForWindowEvents) {
351             event->setCurrentTarget(documentForWindowEvents);
352             documentForWindowEvents->handleWindowEvent(event.get(), false);
353             if (event->propagationStopped() || event->cancelBubble())
354                 goto doneDispatching;
355         }
356     }
357
358 doneDispatching:
359     event->setCurrentTarget(0);
360     event->setEventPhase(0);
361
362     // Pass the data from the preDispatchEventHandler to the postDispatchEventHandler.
363     postDispatchEventHandler(event.get(), data);
364
365     // Call default event handlers. While the DOM does have a concept of preventing
366     // default handling, the detail of which handlers are called is an internal
367     // implementation detail and not part of the DOM.
368     if (!event->defaultPrevented() && !event->defaultHandled()) {
369         // Non-bubbling events call only one default event handler, the one for the target.
370         defaultEventHandler(event.get());
371         ASSERT(!event->defaultPrevented());
372         if (event->defaultHandled())
373             goto doneWithDefault;
374         // For bubbling events, call default event handlers on the same targets in the
375         // same order as the bubbling phase.
376         if (event->bubbles()) {
377             size_t size = ancestors.size();
378             for (size_t i = 0; i < size; ++i) {
379                 ContainerNode* ancestor = ancestors[i].get();
380                 ancestor->defaultEventHandler(event.get());
381                 ASSERT(!event->defaultPrevented());
382                 if (event->defaultHandled())
383                     goto doneWithDefault;
384             }
385         }
386     }
387
388 doneWithDefault:
389     Document::updateDocumentsRendering();
390
391     return !event->defaultPrevented();
392 }
393
394 bool EventTargetNode::dispatchSubtreeModifiedEvent()
395 {
396     ASSERT(!eventDispatchForbidden());
397     
398     document()->incDOMTreeVersion();
399
400     notifyNodeListsAttributeChanged(); // FIXME: Can do better some day. Really only care about the name attribute changing.
401     
402     if (!document()->hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
403         return false;
404     ExceptionCode ec = 0;
405     return dispatchEvent(MutationEvent::create(eventNames().DOMSubtreeModifiedEvent, true, false, 0, String(), String(), String(), 0), ec);
406 }
407
408 void EventTargetNode::dispatchWindowEvent(PassRefPtr<Event> e)
409 {
410     ASSERT(!eventDispatchForbidden());
411     RefPtr<Event> evt(e);
412     RefPtr<Document> doc = document();
413     evt->setTarget(doc);
414     doc->handleWindowEvent(evt.get(), true);
415     doc->handleWindowEvent(evt.get(), false);
416 }
417
418 void EventTargetNode::dispatchWindowEvent(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg)
419 {
420     ASSERT(!eventDispatchForbidden());
421     RefPtr<Document> doc = document();
422     dispatchWindowEvent(Event::create(eventType, canBubbleArg, cancelableArg));
423     
424     if (eventType == eventNames().loadEvent) {
425         // For onload events, send a separate load event to the enclosing frame only.
426         // This is a DOM extension and is independent of bubbling/capturing rules of
427         // the DOM.
428         Element* ownerElement = doc->ownerElement();
429         if (ownerElement) {
430             RefPtr<Event> ownerEvent = Event::create(eventType, false, cancelableArg);
431             ownerEvent->setTarget(ownerElement);
432             ownerElement->dispatchGenericEvent(ownerEvent.release());
433         }
434     }
435 }
436
437 bool EventTargetNode::dispatchUIEvent(const AtomicString& eventType, int detail, PassRefPtr<Event> underlyingEvent)
438 {
439     ASSERT(!eventDispatchForbidden());
440     ASSERT(eventType == eventNames().DOMFocusInEvent || eventType == eventNames().DOMFocusOutEvent || eventType == eventNames().DOMActivateEvent);
441     
442     bool cancelable = eventType == eventNames().DOMActivateEvent;
443     
444     ExceptionCode ec = 0;
445     RefPtr<UIEvent> evt = UIEvent::create(eventType, true, cancelable, document()->defaultView(), detail);
446     evt->setUnderlyingEvent(underlyingEvent);
447     return dispatchEvent(evt.release(), ec);
448 }
449
450 bool EventTargetNode::dispatchKeyEvent(const PlatformKeyboardEvent& key)
451 {
452     ASSERT(!eventDispatchForbidden());
453     ExceptionCode ec = 0;
454     RefPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(key, document()->defaultView());
455     bool r = dispatchEvent(keyboardEvent, ec);
456     
457     // we want to return false if default is prevented (already taken care of)
458     // or if the element is default-handled by the DOM. Otherwise we let it just
459     // let it get handled by AppKit 
460     if (keyboardEvent->defaultHandled())
461         r = false;
462     
463     return r;
464 }
465
466 bool EventTargetNode::dispatchMouseEvent(const PlatformMouseEvent& event, const AtomicString& eventType,
467     int detail, Node* relatedTarget)
468 {
469     ASSERT(!eventDispatchForbidden());
470     
471     IntPoint contentsPos;
472     if (FrameView* view = document()->view())
473         contentsPos = view->windowToContents(event.pos());
474
475     short button = event.button();
476
477     ASSERT(event.eventType() == MouseEventMoved || button != NoButton);
478     
479     return dispatchMouseEvent(eventType, button, detail,
480         contentsPos.x(), contentsPos.y(), event.globalX(), event.globalY(),
481         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
482         false, relatedTarget);
483 }
484
485 void EventTargetNode::dispatchSimulatedMouseEvent(const AtomicString& eventType,
486     PassRefPtr<Event> underlyingEvent)
487 {
488     ASSERT(!eventDispatchForbidden());
489
490     bool ctrlKey = false;
491     bool altKey = false;
492     bool shiftKey = false;
493     bool metaKey = false;
494     if (UIEventWithKeyState* keyStateEvent = findEventWithKeyState(underlyingEvent.get())) {
495         ctrlKey = keyStateEvent->ctrlKey();
496         altKey = keyStateEvent->altKey();
497         shiftKey = keyStateEvent->shiftKey();
498         metaKey = keyStateEvent->metaKey();
499     }
500
501     // Like Gecko, we just pass 0 for everything when we make a fake mouse event.
502     // Internet Explorer instead gives the current mouse position and state.
503     dispatchMouseEvent(eventType, 0, 0, 0, 0, 0, 0,
504         ctrlKey, altKey, shiftKey, metaKey, true, 0, underlyingEvent);
505 }
506
507 void EventTargetNode::dispatchSimulatedClick(PassRefPtr<Event> event, bool sendMouseEvents, bool showPressedLook)
508 {
509     if (!gNodesDispatchingSimulatedClicks)
510         gNodesDispatchingSimulatedClicks = new HashSet<EventTargetNode*>;
511     else if (gNodesDispatchingSimulatedClicks->contains(this))
512         return;
513     
514     gNodesDispatchingSimulatedClicks->add(this);
515     
516     // send mousedown and mouseup before the click, if requested
517     if (sendMouseEvents)
518         dispatchSimulatedMouseEvent(eventNames().mousedownEvent, event.get());
519     setActive(true, showPressedLook);
520     if (sendMouseEvents)
521         dispatchSimulatedMouseEvent(eventNames().mouseupEvent, event.get());
522     setActive(false);
523
524     // always send click
525     dispatchSimulatedMouseEvent(eventNames().clickEvent, event);
526     
527     gNodesDispatchingSimulatedClicks->remove(this);
528 }
529
530 bool EventTargetNode::dispatchMouseEvent(const AtomicString& eventType, int button, int detail,
531     int pageX, int pageY, int screenX, int screenY,
532     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, 
533     bool isSimulated, Node* relatedTargetArg, PassRefPtr<Event> underlyingEvent)
534 {
535     ASSERT(!eventDispatchForbidden());
536     if (disabled()) // Don't even send DOM events for disabled controls..
537         return true;
538     
539     if (eventType.isEmpty())
540         return false; // Shouldn't happen.
541     
542     // Dispatching the first event can easily result in this node being destroyed.
543     // Since we dispatch up to three events here, we need to make sure we're referenced
544     // so the pointer will be good for the two subsequent ones.
545     RefPtr<Node> protect(this);
546     
547     bool cancelable = eventType != eventNames().mousemoveEvent;
548     
549     ExceptionCode ec = 0;
550     
551     bool swallowEvent = false;
552     
553     // Attempting to dispatch with a non-EventTarget relatedTarget causes the relatedTarget to be silently ignored.
554     RefPtr<EventTargetNode> relatedTarget = (relatedTargetArg && relatedTargetArg->isEventTargetNode())
555         ? static_cast<EventTargetNode*>(relatedTargetArg) : 0;
556
557     if (Frame* frame = document()->frame()) {
558         float pageZoom = frame->pageZoomFactor();
559         if (pageZoom != 1.0f) {
560             // Adjust our pageX and pageY to account for the page zoom.
561             pageX = lroundf(pageX / pageZoom);
562             pageY = lroundf(pageY / pageZoom);
563         }
564     }
565
566     RefPtr<Event> mouseEvent = MouseEvent::create(eventType,
567         true, cancelable, document()->defaultView(),
568         detail, screenX, screenY, pageX, pageY,
569         ctrlKey, altKey, shiftKey, metaKey, button,
570         relatedTarget, 0, isSimulated);
571     mouseEvent->setUnderlyingEvent(underlyingEvent.get());
572     
573     dispatchEvent(mouseEvent, ec);
574     bool defaultHandled = mouseEvent->defaultHandled();
575     bool defaultPrevented = mouseEvent->defaultPrevented();
576     if (defaultHandled || defaultPrevented)
577         swallowEvent = true;
578     
579     // Special case: If it's a double click event, we also send the dblclick event. This is not part
580     // of the DOM specs, but is used for compatibility with the ondblclick="" attribute.  This is treated
581     // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same.
582     if (eventType == eventNames().clickEvent && detail == 2) {
583         RefPtr<Event> doubleClickEvent = MouseEvent::create(eventNames().dblclickEvent,
584             true, cancelable, document()->defaultView(),
585             detail, screenX, screenY, pageX, pageY,
586             ctrlKey, altKey, shiftKey, metaKey, button,
587             relatedTarget, 0, isSimulated);
588         doubleClickEvent->setUnderlyingEvent(underlyingEvent.get());
589         if (defaultHandled)
590             doubleClickEvent->setDefaultHandled();
591         dispatchEvent(doubleClickEvent, ec);
592         if (doubleClickEvent->defaultHandled() || doubleClickEvent->defaultPrevented())
593             swallowEvent = true;
594     }
595
596     return swallowEvent;
597 }
598
599 void EventTargetNode::dispatchWheelEvent(PlatformWheelEvent& e)
600 {
601     ASSERT(!eventDispatchForbidden());
602     if (e.deltaX() == 0 && e.deltaY() == 0)
603         return;
604     
605     FrameView* view = document()->view();
606     if (!view)
607         return;
608     
609     IntPoint pos = view->windowToContents(e.pos());
610     
611     // Convert the deltas from pixels to lines if we have a pixel scroll event.
612     float deltaX = e.deltaX();
613     float deltaY = e.deltaY();
614     
615     // FIXME: Should we do anything with a ScrollByPageWheelEvent here?
616     // It will be treated like a line scroll of 1 right now.
617     if (e.granularity() == ScrollByPixelWheelEvent) {
618         deltaX /= cMouseWheelPixelsPerLineStep;
619         deltaY /= cMouseWheelPixelsPerLineStep;
620     }
621
622     RefPtr<WheelEvent> we = WheelEvent::create(e.deltaX(), e.deltaY(),
623         document()->defaultView(), e.globalX(), e.globalY(), pos.x(), pos.y(),
624         e.ctrlKey(), e.altKey(), e.shiftKey(), e.metaKey());
625     ExceptionCode ec = 0;
626     if (!dispatchEvent(we.release(), ec))
627         e.accept();
628 }
629
630 bool EventTargetNode::dispatchWebKitAnimationEvent(const AtomicString& eventType, const String& animationName, double elapsedTime)
631 {
632     ASSERT(!eventDispatchForbidden());
633     
634     ExceptionCode ec = 0;
635     return dispatchEvent(WebKitAnimationEvent::create(eventType, animationName, elapsedTime), ec);
636 }
637
638 bool EventTargetNode::dispatchWebKitTransitionEvent(const AtomicString& eventType, const String& propertyName, double elapsedTime)
639 {
640     ASSERT(!eventDispatchForbidden());
641     
642     ExceptionCode ec = 0;
643     return dispatchEvent(WebKitTransitionEvent::create(eventType, propertyName, elapsedTime), ec);
644 }
645
646 void EventTargetNode::dispatchFocusEvent()
647 {
648     dispatchEventForType(eventNames().focusEvent, false, false);
649 }
650
651 void EventTargetNode::dispatchBlurEvent()
652 {
653     dispatchEventForType(eventNames().blurEvent, false, false);
654 }
655
656 bool EventTargetNode::dispatchEventForType(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg)
657 {
658     ASSERT(!eventDispatchForbidden());
659     ExceptionCode ec = 0;
660     return dispatchEvent(Event::create(eventType, canBubbleArg, cancelableArg), ec);
661 }
662
663 bool EventTargetNode::dispatchProgressEvent(const AtomicString &eventType, bool lengthComputableArg, unsigned loadedArg, unsigned totalArg)
664 {
665     ASSERT(!eventDispatchForbidden());
666     ExceptionCode ec = 0;
667     return dispatchEvent(ProgressEvent::create(eventType, lengthComputableArg, loadedArg, totalArg), ec);
668 }
669
670 void EventTargetNode::dispatchStorageEvent(const AtomicString &eventType, const String& key, const String& oldValue, const String& newValue, Frame* source)
671 {
672 #if ENABLE(DOM_STORAGE)
673     ASSERT(!eventDispatchForbidden());
674     ExceptionCode ec = 0;
675     dispatchEvent(StorageEvent::create(eventType, key, oldValue, newValue, source->document()->documentURI(), source->domWindow()), ec);
676 #endif
677 }
678
679 void EventTargetNode::removeInlineEventListenerForType(const AtomicString& eventType)
680 {
681     if (!hasRareData())
682         return;
683
684     RegisteredEventListenerVector* listeners = rareData()->listeners();
685     if (!listeners)
686         return;
687
688     size_t size = listeners->size();
689     for (size_t i = 0; i < size; ++i) {
690         RegisteredEventListener& r = *listeners->at(i);
691         if (r.eventType() != eventType || !r.listener()->isInline())
692             continue;
693
694         r.setRemoved(true);
695         listeners->remove(i);
696
697         // removed last
698         if (listeners->isEmpty() && !inDocument())
699             document()->unregisterDisconnectedNodeWithEventListeners(this);
700
701         updateSVGElementInstancesAfterEventListenerChange(this);
702         return;
703     }
704 }
705
706 void EventTargetNode::setInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener> listener)
707 {
708     // In case we are the only one holding a reference to it, we don't want removeInlineEventListenerForType to destroy it.
709     removeInlineEventListenerForType(eventType);
710     if (listener)
711         addEventListener(eventType, listener, false);
712 }
713
714 void EventTargetNode::setInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute* attr)
715 {
716     setInlineEventListenerForType(eventType, document()->createEventListener(attr->localName().string(), attr->value(), this));
717 }
718
719 EventListener* EventTargetNode::inlineEventListenerForType(const AtomicString& eventType) const
720 {
721     const RegisteredEventListenerVector& listeners = eventListeners();
722     size_t size = listeners.size();
723     for (size_t i = 0; i < size; ++i) {
724         const RegisteredEventListener& r = *listeners[i];
725         if (r.eventType() == eventType && r.listener()->isInline())
726             return r.listener();
727     }
728     return 0;
729 }
730
731 bool EventTargetNode::disabled() const
732 {
733     return false;
734 }
735
736 void EventTargetNode::defaultEventHandler(Event* event)
737 {
738     if (event->target() != this)
739         return;
740     const AtomicString& eventType = event->type();
741     if (eventType == eventNames().keydownEvent || eventType == eventNames().keypressEvent) {
742         if (event->isKeyboardEvent())
743             if (Frame* frame = document()->frame())
744                 frame->eventHandler()->defaultKeyboardEventHandler(static_cast<KeyboardEvent*>(event));
745     } else if (eventType == eventNames().clickEvent) {
746         int detail = event->isUIEvent() ? static_cast<UIEvent*>(event)->detail() : 0;
747         dispatchUIEvent(eventNames().DOMActivateEvent, detail, event);
748     } else if (eventType == eventNames().contextmenuEvent) {
749         if (Frame* frame = document()->frame())
750             if (Page* page = frame->page())
751                 page->contextMenuController()->handleContextMenuEvent(event);
752     } else if (eventType == eventNames().textInputEvent) {
753         if (event->isTextEvent())
754             if (Frame* frame = document()->frame())
755                 frame->eventHandler()->defaultTextInputEventHandler(static_cast<TextEvent*>(event));
756     }
757 }
758
759 EventListener* EventTargetNode::onabort() const
760 {
761     return inlineEventListenerForType(eventNames().abortEvent);
762 }
763
764 void EventTargetNode::setOnabort(PassRefPtr<EventListener> eventListener)
765 {
766     setInlineEventListenerForType(eventNames().abortEvent, eventListener);
767 }
768
769 EventListener* EventTargetNode::onblur() const
770 {
771     return inlineEventListenerForType(eventNames().blurEvent);
772 }
773
774 void EventTargetNode::setOnblur(PassRefPtr<EventListener> eventListener)
775 {
776     setInlineEventListenerForType(eventNames().blurEvent, eventListener);
777 }
778
779 EventListener* EventTargetNode::onchange() const
780 {
781     return inlineEventListenerForType(eventNames().changeEvent);
782 }
783
784 void EventTargetNode::setOnchange(PassRefPtr<EventListener> eventListener)
785 {
786     setInlineEventListenerForType(eventNames().changeEvent, eventListener);
787 }
788
789 EventListener* EventTargetNode::onclick() const
790 {
791     return inlineEventListenerForType(eventNames().clickEvent);
792 }
793
794 void EventTargetNode::setOnclick(PassRefPtr<EventListener> eventListener)
795 {
796     setInlineEventListenerForType(eventNames().clickEvent, eventListener);
797 }
798
799 EventListener* EventTargetNode::oncontextmenu() const
800 {
801     return inlineEventListenerForType(eventNames().contextmenuEvent);
802 }
803
804 void EventTargetNode::setOncontextmenu(PassRefPtr<EventListener> eventListener)
805 {
806     setInlineEventListenerForType(eventNames().contextmenuEvent, eventListener);
807 }
808
809 EventListener* EventTargetNode::ondblclick() const
810 {
811     return inlineEventListenerForType(eventNames().dblclickEvent);
812 }
813
814 void EventTargetNode::setOndblclick(PassRefPtr<EventListener> eventListener)
815 {
816     setInlineEventListenerForType(eventNames().dblclickEvent, eventListener);
817 }
818
819 EventListener* EventTargetNode::onerror() const
820 {
821     return inlineEventListenerForType(eventNames().errorEvent);
822 }
823
824 void EventTargetNode::setOnerror(PassRefPtr<EventListener> eventListener)
825 {
826     setInlineEventListenerForType(eventNames().errorEvent, eventListener);
827 }
828
829 EventListener* EventTargetNode::onfocus() const
830 {
831     return inlineEventListenerForType(eventNames().focusEvent);
832 }
833
834 void EventTargetNode::setOnfocus(PassRefPtr<EventListener> eventListener)
835 {
836     setInlineEventListenerForType(eventNames().focusEvent, eventListener);
837 }
838
839 EventListener* EventTargetNode::oninput() const
840 {
841     return inlineEventListenerForType(eventNames().inputEvent);
842 }
843
844 void EventTargetNode::setOninput(PassRefPtr<EventListener> eventListener)
845 {
846     setInlineEventListenerForType(eventNames().inputEvent, eventListener);
847 }
848
849 EventListener* EventTargetNode::onkeydown() const
850 {
851     return inlineEventListenerForType(eventNames().keydownEvent);
852 }
853
854 void EventTargetNode::setOnkeydown(PassRefPtr<EventListener> eventListener)
855 {
856     setInlineEventListenerForType(eventNames().keydownEvent, eventListener);
857 }
858
859 EventListener* EventTargetNode::onkeypress() const
860 {
861     return inlineEventListenerForType(eventNames().keypressEvent);
862 }
863
864 void EventTargetNode::setOnkeypress(PassRefPtr<EventListener> eventListener)
865 {
866     setInlineEventListenerForType(eventNames().keypressEvent, eventListener);
867 }
868
869 EventListener* EventTargetNode::onkeyup() const
870 {
871     return inlineEventListenerForType(eventNames().keyupEvent);
872 }
873
874 void EventTargetNode::setOnkeyup(PassRefPtr<EventListener> eventListener)
875 {
876     setInlineEventListenerForType(eventNames().keyupEvent, eventListener);
877 }
878
879 EventListener* EventTargetNode::onload() const
880 {
881     return inlineEventListenerForType(eventNames().loadEvent);
882 }
883
884 void EventTargetNode::setOnload(PassRefPtr<EventListener> eventListener)
885 {
886     setInlineEventListenerForType(eventNames().loadEvent, eventListener);
887 }
888
889 EventListener* EventTargetNode::onmousedown() const
890 {
891     return inlineEventListenerForType(eventNames().mousedownEvent);
892 }
893
894 void EventTargetNode::setOnmousedown(PassRefPtr<EventListener> eventListener)
895 {
896     setInlineEventListenerForType(eventNames().mousedownEvent, eventListener);
897 }
898
899 EventListener* EventTargetNode::onmousemove() const
900 {
901     return inlineEventListenerForType(eventNames().mousemoveEvent);
902 }
903
904 void EventTargetNode::setOnmousemove(PassRefPtr<EventListener> eventListener)
905 {
906     setInlineEventListenerForType(eventNames().mousemoveEvent, eventListener);
907 }
908
909 EventListener* EventTargetNode::onmouseout() const
910 {
911     return inlineEventListenerForType(eventNames().mouseoutEvent);
912 }
913
914 void EventTargetNode::setOnmouseout(PassRefPtr<EventListener> eventListener)
915 {
916     setInlineEventListenerForType(eventNames().mouseoutEvent, eventListener);
917 }
918
919 EventListener* EventTargetNode::onmouseover() const
920 {
921     return inlineEventListenerForType(eventNames().mouseoverEvent);
922 }
923
924 void EventTargetNode::setOnmouseover(PassRefPtr<EventListener> eventListener)
925 {
926     setInlineEventListenerForType(eventNames().mouseoverEvent, eventListener);
927 }
928
929 EventListener* EventTargetNode::onmouseup() const
930 {
931     return inlineEventListenerForType(eventNames().mouseupEvent);
932 }
933
934 void EventTargetNode::setOnmouseup(PassRefPtr<EventListener> eventListener)
935 {
936     setInlineEventListenerForType(eventNames().mouseupEvent, eventListener);
937 }
938
939 EventListener* EventTargetNode::onmousewheel() const
940 {
941     return inlineEventListenerForType(eventNames().mousewheelEvent);
942 }
943
944 void EventTargetNode::setOnmousewheel(PassRefPtr<EventListener> eventListener)
945 {
946     setInlineEventListenerForType(eventNames().mousewheelEvent, eventListener);
947 }
948
949 EventListener* EventTargetNode::onbeforecut() const
950 {
951     return inlineEventListenerForType(eventNames().beforecutEvent);
952 }
953
954 void EventTargetNode::setOnbeforecut(PassRefPtr<EventListener> eventListener)
955 {
956     setInlineEventListenerForType(eventNames().beforecutEvent, eventListener);
957 }
958
959 EventListener* EventTargetNode::oncut() const
960 {
961     return inlineEventListenerForType(eventNames().cutEvent);
962 }
963
964 void EventTargetNode::setOncut(PassRefPtr<EventListener> eventListener)
965 {
966     setInlineEventListenerForType(eventNames().cutEvent, eventListener);
967 }
968
969 EventListener* EventTargetNode::onbeforecopy() const
970 {
971     return inlineEventListenerForType(eventNames().beforecopyEvent);
972 }
973
974 void EventTargetNode::setOnbeforecopy(PassRefPtr<EventListener> eventListener)
975 {
976     setInlineEventListenerForType(eventNames().beforecopyEvent, eventListener);
977 }
978
979 EventListener* EventTargetNode::oncopy() const
980 {
981     return inlineEventListenerForType(eventNames().copyEvent);
982 }
983
984 void EventTargetNode::setOncopy(PassRefPtr<EventListener> eventListener)
985 {
986     setInlineEventListenerForType(eventNames().copyEvent, eventListener);
987 }
988
989 EventListener* EventTargetNode::onbeforepaste() const
990 {
991     return inlineEventListenerForType(eventNames().beforepasteEvent);
992 }
993
994 void EventTargetNode::setOnbeforepaste(PassRefPtr<EventListener> eventListener)
995 {
996     setInlineEventListenerForType(eventNames().beforepasteEvent, eventListener);
997 }
998
999 EventListener* EventTargetNode::onpaste() const
1000 {
1001     return inlineEventListenerForType(eventNames().pasteEvent);
1002 }
1003
1004 void EventTargetNode::setOnpaste(PassRefPtr<EventListener> eventListener)
1005 {
1006     setInlineEventListenerForType(eventNames().pasteEvent, eventListener);
1007 }
1008
1009 EventListener* EventTargetNode::ondragenter() const
1010 {
1011     return inlineEventListenerForType(eventNames().dragenterEvent);
1012 }
1013
1014 void EventTargetNode::setOndragenter(PassRefPtr<EventListener> eventListener)
1015 {
1016     setInlineEventListenerForType(eventNames().dragenterEvent, eventListener);
1017 }
1018
1019 EventListener* EventTargetNode::ondragover() const
1020 {
1021     return inlineEventListenerForType(eventNames().dragoverEvent);
1022 }
1023
1024 void EventTargetNode::setOndragover(PassRefPtr<EventListener> eventListener)
1025 {
1026     setInlineEventListenerForType(eventNames().dragoverEvent, eventListener);
1027 }
1028
1029 EventListener* EventTargetNode::ondragleave() const
1030 {
1031     return inlineEventListenerForType(eventNames().dragleaveEvent);
1032 }
1033
1034 void EventTargetNode::setOndragleave(PassRefPtr<EventListener> eventListener)
1035 {
1036     setInlineEventListenerForType(eventNames().dragleaveEvent, eventListener);
1037 }
1038
1039 EventListener* EventTargetNode::ondrop() const
1040 {
1041     return inlineEventListenerForType(eventNames().dropEvent);
1042 }
1043
1044 void EventTargetNode::setOndrop(PassRefPtr<EventListener> eventListener)
1045 {
1046     setInlineEventListenerForType(eventNames().dropEvent, eventListener);
1047 }
1048
1049 EventListener* EventTargetNode::ondragstart() const
1050 {
1051     return inlineEventListenerForType(eventNames().dragstartEvent);
1052 }
1053
1054 void EventTargetNode::setOndragstart(PassRefPtr<EventListener> eventListener)
1055 {
1056     setInlineEventListenerForType(eventNames().dragstartEvent, eventListener);
1057 }
1058
1059 EventListener* EventTargetNode::ondrag() const
1060 {
1061     return inlineEventListenerForType(eventNames().dragEvent);
1062 }
1063
1064 void EventTargetNode::setOndrag(PassRefPtr<EventListener> eventListener)
1065 {
1066     setInlineEventListenerForType(eventNames().dragEvent, eventListener);
1067 }
1068
1069 EventListener* EventTargetNode::ondragend() const
1070 {
1071     return inlineEventListenerForType(eventNames().dragendEvent);
1072 }
1073
1074 void EventTargetNode::setOndragend(PassRefPtr<EventListener> eventListener)
1075 {
1076     setInlineEventListenerForType(eventNames().dragendEvent, eventListener);
1077 }
1078
1079 EventListener* EventTargetNode::onreset() const
1080 {
1081     return inlineEventListenerForType(eventNames().resetEvent);
1082 }
1083
1084 void EventTargetNode::setOnreset(PassRefPtr<EventListener> eventListener)
1085 {
1086     setInlineEventListenerForType(eventNames().resetEvent, eventListener);
1087 }
1088
1089 EventListener* EventTargetNode::onresize() const
1090 {
1091     return inlineEventListenerForType(eventNames().resizeEvent);
1092 }
1093
1094 void EventTargetNode::setOnresize(PassRefPtr<EventListener> eventListener)
1095 {
1096     setInlineEventListenerForType(eventNames().resizeEvent, eventListener);
1097 }
1098
1099 EventListener* EventTargetNode::onscroll() const
1100 {
1101     return inlineEventListenerForType(eventNames().scrollEvent);
1102 }
1103
1104 void EventTargetNode::setOnscroll(PassRefPtr<EventListener> eventListener)
1105 {
1106     setInlineEventListenerForType(eventNames().scrollEvent, eventListener);
1107 }
1108
1109 EventListener* EventTargetNode::onsearch() const
1110 {
1111     return inlineEventListenerForType(eventNames().searchEvent);
1112 }
1113
1114 void EventTargetNode::setOnsearch(PassRefPtr<EventListener> eventListener)
1115 {
1116     setInlineEventListenerForType(eventNames().searchEvent, eventListener);
1117 }
1118
1119 EventListener* EventTargetNode::onselect() const
1120 {
1121     return inlineEventListenerForType(eventNames().selectEvent);
1122 }
1123
1124 void EventTargetNode::setOnselect(PassRefPtr<EventListener> eventListener)
1125 {
1126     setInlineEventListenerForType(eventNames().selectEvent, eventListener);
1127 }
1128
1129 EventListener* EventTargetNode::onselectstart() const
1130 {
1131     return inlineEventListenerForType(eventNames().selectstartEvent);
1132 }
1133
1134 void EventTargetNode::setOnselectstart(PassRefPtr<EventListener> eventListener)
1135 {
1136     setInlineEventListenerForType(eventNames().selectstartEvent, eventListener);
1137 }
1138
1139 EventListener* EventTargetNode::onsubmit() const
1140 {
1141     return inlineEventListenerForType(eventNames().submitEvent);
1142 }
1143
1144 void EventTargetNode::setOnsubmit(PassRefPtr<EventListener> eventListener)
1145 {
1146     setInlineEventListenerForType(eventNames().submitEvent, eventListener);
1147 }
1148
1149 EventListener* EventTargetNode::onunload() const
1150 {
1151     return inlineEventListenerForType(eventNames().unloadEvent);
1152 }
1153
1154 void EventTargetNode::setOnunload(PassRefPtr<EventListener> eventListener)
1155 {
1156     setInlineEventListenerForType(eventNames().unloadEvent, eventListener);
1157 }
1158
1159 } // namespace WebCore