#include "config.h"
#include "EventTarget.h"
#include "Event.h"
#include "EventException.h"
#include "InspectorInstrumentation.h"
#include "ScriptController.h"
#include "WebKitTransitionEvent.h"
#include <wtf/MainThread.h>
#include <wtf/StdLibExtras.h>
#include <wtf/Vector.h>
using namespace WTF;
namespace WebCore {
EventTargetData::EventTargetData()
{
}
EventTargetData::~EventTargetData()
{
}
EventTarget::~EventTarget()
{
}
Node* EventTarget::toNode()
{
return 0;
}
DOMWindow* EventTarget::toDOMWindow()
{
return 0;
}
bool EventTarget::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
EventTargetData* d = ensureEventTargetData();
return d->eventListenerMap.add(eventType, listener, useCapture);
}
bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
{
EventTargetData* d = eventTargetData();
if (!d)
return false;
size_t indexOfRemovedListener;
if (!d->eventListenerMap.remove(eventType, listener, useCapture, indexOfRemovedListener))
return false;
if (!d->firingEventIterators)
return true;
for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
FiringEventIterator& firingIterator = d->firingEventIterators->at(i);
if (eventType != firingIterator.eventType)
continue;
if (indexOfRemovedListener >= firingIterator.end)
continue;
--firingIterator.end;
if (indexOfRemovedListener <= firingIterator.iterator)
--firingIterator.iterator;
}
return true;
}
bool EventTarget::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
{
clearAttributeEventListener(eventType);
if (!listener)
return false;
return addEventListener(eventType, listener, false);
}
EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType)
{
const EventListenerVector& entry = getEventListeners(eventType);
for (size_t i = 0; i < entry.size(); ++i) {
if (entry[i].listener->isAttribute())
return entry[i].listener.get();
}
return 0;
}
bool EventTarget::clearAttributeEventListener(const AtomicString& eventType)
{
EventListener* listener = getAttributeEventListener(eventType);
if (!listener)
return false;
return removeEventListener(eventType, listener, false);
}
bool EventTarget::dispatchEvent(PassRefPtr<Event> event, ExceptionCode& ec)
{
if (!event || event->type().isEmpty()) {
ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
return false;
}
if (event->isBeingDispatched()) {
ec = EventException::DISPATCH_REQUEST_ERR;
return false;
}
if (!scriptExecutionContext())
return false;
return dispatchEvent(event);
}
bool EventTarget::dispatchEvent(PassRefPtr<Event> event)
{
event->setTarget(this);
event->setCurrentTarget(this);
event->setEventPhase(Event::AT_TARGET);
bool defaultPrevented = fireEventListeners(event.get());
event->setEventPhase(0);
return defaultPrevented;
}
void EventTarget::uncaughtExceptionInEventHandler()
{
}
static AtomicString prefixedType(const Event* event)
{
if (event->type() == eventNames().transitionendEvent)
return eventNames().webkitTransitionEndEvent;
return emptyString();
}
bool EventTarget::fireEventListeners(Event* event)
{
ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
ASSERT(event && !event->type().isEmpty());
EventTargetData* d = eventTargetData();
if (!d)
return true;
EventListenerVector* listenerPrefixedVector = 0;
AtomicString prefixedTypeName = prefixedType(event);
if (!prefixedTypeName.isEmpty())
listenerPrefixedVector = d->eventListenerMap.find(prefixedTypeName);
EventListenerVector* listenerUnprefixedVector = d->eventListenerMap.find(event->type());
if (listenerUnprefixedVector)
fireEventListeners(event, d, *listenerUnprefixedVector);
else if (listenerPrefixedVector) {
AtomicString unprefixedTypeName = event->type();
event->setType(prefixedTypeName);
fireEventListeners(event, d, *listenerPrefixedVector);
event->setType(unprefixedTypeName);
}
if (!prefixedTypeName.isEmpty()) {
ScriptExecutionContext* context = scriptExecutionContext();
if (context && context->isDocument()) {
Document* document = toDocument(context);
if (document->domWindow()) {
if (listenerPrefixedVector)
if (listenerUnprefixedVector)
FeatureObserver::observe(document->domWindow(), FeatureObserver::PrefixedAndUnprefixedTransitionEndEvent);
else
FeatureObserver::observe(document->domWindow(), FeatureObserver::PrefixedTransitionEndEvent);
else if (listenerUnprefixedVector)
FeatureObserver::observe(document->domWindow(), FeatureObserver::UnprefixedTransitionEndEvent);
}
}
}
return !event->defaultPrevented();
}
void EventTarget::fireEventListeners(Event* event, EventTargetData* d, EventListenerVector& entry)
{
RefPtr<EventTarget> protect = this;
bool userEventWasHandled = false;
size_t i = 0;
size_t end = entry.size();
if (!d->firingEventIterators)
d->firingEventIterators = adoptPtr(new FiringEventIteratorVector);
d->firingEventIterators->append(FiringEventIterator(event->type(), i, end));
for ( ; i < end; ++i) {
RegisteredEventListener& registeredListener = entry[i];
if (event->eventPhase() == Event::CAPTURING_PHASE && !registeredListener.useCapture)
continue;
if (event->eventPhase() == Event::BUBBLING_PHASE && registeredListener.useCapture)
continue;
if (event->immediatePropagationStopped())
break;
ScriptExecutionContext* context = scriptExecutionContext();
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(context, event);
registeredListener.listener->handleEvent(context, event);
if (!userEventWasHandled && ScriptController::processingUserGesture())
userEventWasHandled = true;
InspectorInstrumentation::didHandleEvent(cookie);
}
d->firingEventIterators->removeLast();
if (userEventWasHandled) {
ScriptExecutionContext* context = scriptExecutionContext();
if (context && context->isDocument()) {
Document* document = toDocument(context);
document->resetLastHandledUserGestureTimestamp();
}
}
}
const EventListenerVector& EventTarget::getEventListeners(const AtomicString& eventType)
{
DEFINE_STATIC_LOCAL(EventListenerVector, emptyVector, ());
EventTargetData* d = eventTargetData();
if (!d)
return emptyVector;
EventListenerVector* listenerVector = d->eventListenerMap.find(eventType);
if (!listenerVector)
return emptyVector;
return *listenerVector;
}
void EventTarget::removeAllEventListeners()
{
EventTargetData* d = eventTargetData();
if (!d)
return;
d->eventListenerMap.clear();
if (d->firingEventIterators) {
for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
d->firingEventIterators->at(i).iterator = 0;
d->firingEventIterators->at(i).end = 0;
}
}
}
}