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