src/third_party/WebKit/Source/core/events/Event.h

   1 /*
   2  * Copyright (C) 2001 Peter Kelly (pmk@post.com)
   3  * Copyright (C) 2001 Tobias Anton (anton@stud.fbi.fh-darmstadt.de)
   4  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
   5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public License
  18  * along with this library; see the file COPYING.LIB.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  *
  22  */
  23
  24 #ifndef Event_h
  25 #define Event_h
  26
  27 #include "bindings/v8/ScriptWrappable.h"
  28 #include "core/dom/DOMTimeStamp.h"
  29 #include "core/events/EventPath.h"
  30 #include "platform/heap/Handle.h"
  31 #include "wtf/RefCounted.h"
  32 #include "wtf/text/AtomicString.h"
  33
  34 namespace WebCore {
  35
  36 class EventTarget;
  37 class EventDispatcher;
  38 class ExecutionContext;
  39 class HTMLIFrameElement;
  40
  41 struct EventInit {
  42     STACK_ALLOCATED();
  43 public:
  44     EventInit();
  45
  46     bool bubbles;
  47     bool cancelable;
  48 };
  49
  50 class Event : public RefCountedWillBeGarbageCollectedFinalized<Event>,  public ScriptWrappable {
  51 public:
  52     enum PhaseType {
  53         NONE                = 0,
  54         CAPTURING_PHASE     = 1,
  55         AT_TARGET           = 2,
  56         BUBBLING_PHASE      = 3
  57     };
  58
  59     enum EventType {
  60         MOUSEDOWN           = 1,
  61         MOUSEUP             = 2,
  62         MOUSEOVER           = 4,
  63         MOUSEOUT            = 8,
  64         MOUSEMOVE           = 16,
  65         MOUSEDRAG           = 32,
  66         CLICK               = 64,
  67         DBLCLICK            = 128,
  68         KEYDOWN             = 256,
  69         KEYUP               = 512,
  70         KEYPRESS            = 1024,
  71         DRAGDROP            = 2048,
  72         FOCUS               = 4096,
  73         BLUR                = 8192,
  74         SELECT              = 16384,
  75         CHANGE              = 32768
  76     };
  77
  78     static PassRefPtrWillBeRawPtr<Event> create()
  79     {
  80         return adoptRefWillBeNoop(new Event);
  81     }
  82
  83     // A factory for a simple event. The event doesn't bubble, and isn't
  84     // cancelable.
  85     // http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#fire-a-simple-event
  86     static PassRefPtrWillBeRawPtr<Event> create(const AtomicString& type)
  87     {
  88         return adoptRefWillBeNoop(new Event(type, false, false));
  89     }
  90     static PassRefPtrWillBeRawPtr<Event> createCancelable(const AtomicString& type)
  91     {
  92         return adoptRefWillBeNoop(new Event(type, false, true));
  93     }
  94     static PassRefPtrWillBeRawPtr<Event> createBubble(const AtomicString& type)
  95     {
  96         return adoptRefWillBeNoop(new Event(type, true, false));
  97     }
  98     static PassRefPtrWillBeRawPtr<Event> createCancelableBubble(const AtomicString& type)
  99     {
 100         return adoptRefWillBeNoop(new Event(type, true, true));
 101     }
 102
 103     static PassRefPtrWillBeRawPtr<Event> create(const AtomicString& type, const EventInit& initializer)
 104     {
 105         return adoptRefWillBeNoop(new Event(type, initializer));
 106     }
 107
 108     virtual ~Event();
 109
 110     void initEvent(const AtomicString& type, bool canBubble, bool cancelable);
 111
 112     const AtomicString& type() const { return m_type; }
 113     void setType(const AtomicString& type) { m_type = type; }
 114
 115     EventTarget* target() const { return m_target.get(); }
 116     void setTarget(PassRefPtr<EventTarget>);
 117
 118     EventTarget* currentTarget() const { return m_currentTarget; }
 119     void setCurrentTarget(EventTarget* currentTarget) { m_currentTarget = currentTarget; }
 120
 121     unsigned short eventPhase() const { return m_eventPhase; }
 122     void setEventPhase(unsigned short eventPhase) { m_eventPhase = eventPhase; }
 123
 124     bool bubbles() const { return m_canBubble; }
 125     bool cancelable() const { return m_cancelable; }
 126     DOMTimeStamp timeStamp() const { return m_createTime; }
 127
 128     void stopPropagation() { m_propagationStopped = true; }
 129     void stopImmediatePropagation() { m_immediatePropagationStopped = true; }
 130
 131     // IE Extensions
 132     EventTarget* srcElement() const { return target(); } // MSIE extension - "the object that fired the event"
 133
 134     bool legacyReturnValue(ExecutionContext*) const;
 135     void setLegacyReturnValue(ExecutionContext*, bool returnValue);
 136
 137     virtual const AtomicString& interfaceName() const;
 138     bool hasInterface(const AtomicString&) const;
 139
 140     // These events are general classes of events.
 141     virtual bool isUIEvent() const;
 142     virtual bool isMouseEvent() const;
 143     virtual bool isFocusEvent() const;
 144     virtual bool isKeyboardEvent() const;
 145     virtual bool isTouchEvent() const;
 146     virtual bool isGestureEvent() const;
 147     virtual bool isWheelEvent() const;
 148
 149     // Drag events are a subset of mouse events.
 150     virtual bool isDragEvent() const;
 151
 152     // These events lack a DOM interface.
 153     virtual bool isClipboardEvent() const;
 154     virtual bool isBeforeTextInsertedEvent() const;
 155
 156     virtual bool isBeforeUnloadEvent() const;
 157
 158     bool propagationStopped() const { return m_propagationStopped || m_immediatePropagationStopped; }
 159     bool immediatePropagationStopped() const { return m_immediatePropagationStopped; }
 160
 161     bool defaultPrevented() const { return m_defaultPrevented; }
 162     virtual void preventDefault()
 163     {
 164         if (m_cancelable)
 165             m_defaultPrevented = true;
 166     }
 167     void setDefaultPrevented(bool defaultPrevented) { m_defaultPrevented = defaultPrevented; }
 168
 169     bool defaultHandled() const { return m_defaultHandled; }
 170     void setDefaultHandled() { m_defaultHandled = true; }
 171
 172     bool cancelBubble() const { return m_cancelBubble; }
 173     void setCancelBubble(bool cancel) { m_cancelBubble = cancel; }
 174
 175     Event* underlyingEvent() const { return m_underlyingEvent.get(); }
 176     void setUnderlyingEvent(PassRefPtrWillBeRawPtr<Event>);
 177
 178     EventPath& eventPath() { ASSERT(m_eventPath); return *m_eventPath; }
 179     EventPath& ensureEventPath();
 180
 181     PassRefPtr<NodeList> path() const;
 182
 183     bool isBeingDispatched() const { return eventPhase(); }
 184
 185     virtual void trace(Visitor*);
 186
 187 protected:
 188     Event();
 189     Event(const AtomicString& type, bool canBubble, bool cancelable);
 190     Event(const AtomicString& type, const EventInit&);
 191
 192     virtual void receivedTarget();
 193     bool dispatched() const { return m_target; }
 194
 195 private:
 196     AtomicString m_type;
 197     bool m_canBubble;
 198     bool m_cancelable;
 199
 200     bool m_propagationStopped;
 201     bool m_immediatePropagationStopped;
 202     bool m_defaultPrevented;
 203     bool m_defaultHandled;
 204     bool m_cancelBubble;
 205
 206     unsigned short m_eventPhase;
 207     EventTarget* m_currentTarget;
 208     RefPtr<EventTarget> m_target;
 209     DOMTimeStamp m_createTime;
 210     RefPtrWillBeMember<Event> m_underlyingEvent;
 211     OwnPtrWillBeMember<EventPath> m_eventPath;
 212 };
 213
 214 #define DEFINE_EVENT_TYPE_CASTS(typeName) \
 215     DEFINE_TYPE_CASTS(typeName, Event, event, event->is##typeName(), event.is##typeName())
 216
 217 } // namespace WebCore
 218
 219 #endif // Event_h