#include "config.h"
#include "EventTarget.h"
#include "Node.h"
#include "NodeList.h"
#include "Document.h"
#include "Event.h"
#include "EventListener.h"
#include "EventNames.h"
#include "Frame.h"
#include "FrameView.h"
#include "kjs_proxy.h"
#include "RegisteredEventListener.h"
namespace WebCore {
using namespace EventNames;
#ifndef NDEBUG
static int gEventDispatchForbidden = 0;
#endif
EventTarget::~EventTarget()
{
}
EventTargetNode* EventTarget::toNode()
{
return 0;
}
XMLHttpRequest* EventTarget::toXMLHttpRequest()
{
return 0;
}
#if ENABLE(SVG)
SVGElementInstance* EventTarget::toSVGElementInstance()
{
return 0;
}
#endif
static inline void addListenerTypeToDocumentIfNeeded(const AtomicString& eventType, Document* document)
{
Document::ListenerType type = static_cast<Document::ListenerType>(0);
if (eventType == DOMSubtreeModifiedEvent)
type = Document::DOMSUBTREEMODIFIED_LISTENER;
else if (eventType == DOMNodeInsertedEvent)
type = Document::DOMNODEINSERTED_LISTENER;
else if (eventType == DOMNodeRemovedEvent)
type = Document::DOMNODEREMOVED_LISTENER;
else if (eventType == DOMNodeRemovedFromDocumentEvent)
type = Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER;
else if (eventType == DOMNodeInsertedIntoDocumentEvent)
type = Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER;
else if (eventType == DOMAttrModifiedEvent)
type = Document::DOMATTRMODIFIED_LISTENER;
else if (eventType == DOMCharacterDataModifiedEvent)
type = Document::DOMCHARACTERDATAMODIFIED_LISTENER;
else if (eventType == overflowchangedEvent)
type = Document::OVERFLOWCHANGED_LISTENER;
if (type)
document->addListenerType(type);
}
void EventTarget::addEventListener(EventTargetNode* referenceNode, const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
ASSERT(referenceNode);
if (!referenceNode->document()->attached())
return;
addListenerTypeToDocumentIfNeeded(eventType, referenceNode->document());
if (!referenceNode->m_regdListeners)
referenceNode->m_regdListeners = new RegisteredEventListenerList;
removeEventListener(referenceNode, eventType, listener.get(), useCapture);
if (referenceNode->m_regdListeners->isEmpty() && !referenceNode->inDocument())
referenceNode->document()->registerDisconnectedNodeWithEventListeners(referenceNode);
referenceNode->m_regdListeners->append(new RegisteredEventListener(eventType, listener.get(), useCapture));
}
void EventTarget::removeEventListener(EventTargetNode* referenceNode, const AtomicString& eventType, EventListener* listener, bool useCapture)
{
ASSERT(referenceNode);
if (!referenceNode->m_regdListeners)
return;
RegisteredEventListener rl(eventType, listener, useCapture);
RegisteredEventListenerList::Iterator end = referenceNode->m_regdListeners->end();
for (RegisteredEventListenerList::Iterator it = referenceNode->m_regdListeners->begin(); it != end; ++it) {
if (*(*it).get() == rl) {
(*it)->setRemoved(true);
it = referenceNode->m_regdListeners->remove(it);
if (referenceNode->m_regdListeners->isEmpty() && !referenceNode->inDocument())
referenceNode->document()->unregisterDisconnectedNodeWithEventListeners(referenceNode);
return;
}
}
}
bool EventTarget::dispatchGenericEvent(EventTargetNode* referenceNode, PassRefPtr<Event> e, ExceptionCode&, bool tempEvent)
{
RefPtr<Event> evt(e);
ASSERT(!eventDispatchForbidden());
ASSERT(evt->target());
ASSERT(!evt->type().isNull());
DeprecatedPtrList<Node> nodeChain;
if (referenceNode->inDocument()) {
for (Node* n = referenceNode; n; n = n->eventParentNode()) {
n->ref();
nodeChain.prepend(n);
}
} else {
referenceNode->ref();
nodeChain.prepend(referenceNode);
}
DeprecatedPtrListIterator<Node> it(nodeChain);
void* data = preDispatchEventHandler(evt.get());
evt->setEventPhase(Event::CAPTURING_PHASE);
it.toFirst();
if (evt->type() != loadEvent && it.current()->isDocumentNode() && !evt->propagationStopped())
static_cast<Document*>(it.current())->handleWindowEvent(evt.get(), true);
EventTargetNode* eventTargetNode = 0;
for (; it.current() && it.current() != referenceNode && !evt->propagationStopped(); ++it) {
eventTargetNode = EventTargetNodeCast(it.current());
evt->setCurrentTarget(eventTargetRespectingSVGTargetRules(eventTargetNode));
eventTargetNode->handleLocalEvents(evt.get(), true);
}
it.toLast();
if (!evt->propagationStopped()) {
evt->setEventPhase(Event::AT_TARGET);
eventTargetNode = EventTargetNodeCast(it.current());
evt->setCurrentTarget(eventTargetRespectingSVGTargetRules(eventTargetNode));
eventTargetNode->handleLocalEvents(evt.get(), true);
eventTargetNode->handleLocalEvents(evt.get(), false);
}
--it;
if (evt->bubbles()) {
evt->setEventPhase(Event::BUBBLING_PHASE);
for (; it.current() && !evt->propagationStopped() && !evt->cancelBubble(); --it) {
eventTargetNode = EventTargetNodeCast(it.current());
evt->setCurrentTarget(eventTargetRespectingSVGTargetRules(eventTargetNode));
eventTargetNode->handleLocalEvents(evt.get(), false);
}
it.toFirst();
if (evt->type() != loadEvent && it.current()->isDocumentNode() && !evt->propagationStopped() && !evt->cancelBubble()) {
evt->setCurrentTarget(EventTargetNodeCast(it.current()));
static_cast<Document*>(it.current())->handleWindowEvent(evt.get(), false);
}
}
evt->setCurrentTarget(0);
evt->setEventPhase(0);
postDispatchEventHandler(evt.get(), data);
it.toLast();
if (evt->bubbles())
for (; it.current() && !evt->defaultPrevented() && !evt->defaultHandled(); --it)
EventTargetNodeCast(it.current())->defaultEventHandler(evt.get());
else if (!evt->defaultPrevented() && !evt->defaultHandled())
EventTargetNodeCast(it.current())->defaultEventHandler(evt.get());
it.toFirst();
for (; it.current(); ++it)
it.current()->deref();
Document::updateDocumentsRendering();
Frame* frame = referenceNode->document()->frame();
if (tempEvent && frame && frame->scriptProxy()->isEnabled())
frame->scriptProxy()->finishedWithEvent(evt.get());
return !evt->defaultPrevented(); }
void EventTarget::removeAllEventListeners(EventTargetNode* referenceNode)
{
delete referenceNode->m_regdListeners;
referenceNode->m_regdListeners = 0;
}
void EventTarget::insertedIntoDocument(EventTargetNode* referenceNode)
{
if (referenceNode && referenceNode->m_regdListeners && !referenceNode->m_regdListeners->isEmpty())
referenceNode->document()->unregisterDisconnectedNodeWithEventListeners(referenceNode);
}
void EventTarget::removedFromDocument(EventTargetNode* referenceNode)
{
if (referenceNode && referenceNode->m_regdListeners && !referenceNode->m_regdListeners->isEmpty())
referenceNode->document()->registerDisconnectedNodeWithEventListeners(referenceNode);
}
void EventTarget::handleLocalEvents(EventTargetNode* referenceNode, Event* evt, bool useCapture)
{
ASSERT(referenceNode);
if (!referenceNode->m_regdListeners || referenceNode->m_regdListeners->isEmpty())
return;
RegisteredEventListenerList listenersCopy = *referenceNode->m_regdListeners;
RegisteredEventListenerList::Iterator end = listenersCopy.end();
for (RegisteredEventListenerList::Iterator it = listenersCopy.begin(); it != end; ++it) {
if ((*it)->eventType() == evt->type() && (*it)->useCapture() == useCapture && !(*it)->removed())
(*it)->listener()->handleEvent(evt, false);
}
}
EventTarget* EventTarget::eventTargetRespectingSVGTargetRules(EventTargetNode*& referenceNode)
{
return referenceNode;
}
#ifndef NDEBUG
void forbidEventDispatch()
{
++gEventDispatchForbidden;
}
void allowEventDispatch()
{
if (gEventDispatchForbidden > 0)
--gEventDispatchForbidden;
}
bool eventDispatchForbidden()
{
return gEventDispatchForbidden > 0;
}
#endif // NDEBUG
}