Give PlatformEvents a base class
[WebKit-https.git] / Source / WebCore / dom / KeyboardEvent.cpp
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, 2005, 2006, 2007 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 #include "config.h"
24 #include "KeyboardEvent.h"
25
26 #include "Document.h"
27 #include "DOMWindow.h"
28 #include "EventDispatcher.h"
29 #include "EventNames.h"
30 #include "EventHandler.h"
31 #include "Frame.h"
32 #include "PlatformKeyboardEvent.h"
33 #include "Settings.h"
34
35 namespace WebCore {
36
37 static inline const AtomicString& eventTypeForKeyboardEventType(PlatformEvent::Type type)
38 {
39     switch (type) {
40         case PlatformEvent::KeyUp:
41             return eventNames().keyupEvent;
42         case PlatformEvent::RawKeyDown:
43             return eventNames().keydownEvent;
44         case PlatformEvent::Char:
45             return eventNames().keypressEvent;
46         case PlatformEvent::KeyDown:
47             // The caller should disambiguate the combined event into RawKeyDown or Char events.
48             break;
49         default:
50             break;
51     }
52     ASSERT_NOT_REACHED();
53     return eventNames().keydownEvent;
54 }
55
56 KeyboardEvent::KeyboardEvent()
57     : m_keyLocation(DOM_KEY_LOCATION_STANDARD)
58     , m_altGraphKey(false)
59 {
60 }
61
62 KeyboardEvent::KeyboardEvent(const PlatformKeyboardEvent& key, AbstractView* view)
63     : UIEventWithKeyState(eventTypeForKeyboardEventType(key.type()),
64                           true, true, view, 0, key.ctrlKey(), key.altKey(), key.shiftKey(), key.metaKey())
65     , m_keyEvent(adoptPtr(new PlatformKeyboardEvent(key)))
66     , m_keyIdentifier(key.keyIdentifier())
67     , m_keyLocation(key.isKeypad() ? DOM_KEY_LOCATION_NUMPAD : DOM_KEY_LOCATION_STANDARD) // FIXME: differentiate right/left, too
68     , m_altGraphKey(false)
69 {
70 }
71
72 KeyboardEvent::KeyboardEvent(const AtomicString& eventType, bool canBubble, bool cancelable, AbstractView *view,
73                              const String &keyIdentifier,  unsigned keyLocation,
74                              bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, bool altGraphKey)
75     : UIEventWithKeyState(eventType, canBubble, cancelable, view, 0, ctrlKey, altKey, shiftKey, metaKey)
76     , m_keyIdentifier(keyIdentifier)
77     , m_keyLocation(keyLocation)
78     , m_altGraphKey(altGraphKey)
79 {
80 }
81
82 KeyboardEvent::~KeyboardEvent()
83 {
84 }
85
86 void KeyboardEvent::initKeyboardEvent(const AtomicString& type, bool canBubble, bool cancelable, AbstractView* view,
87                                       const String &keyIdentifier, unsigned keyLocation,
88                                       bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, bool altGraphKey)
89 {
90     if (dispatched())
91         return;
92
93     initUIEvent(type, canBubble, cancelable, view, 0);
94
95     m_keyIdentifier = keyIdentifier;
96     m_keyLocation = keyLocation;
97     m_ctrlKey = ctrlKey;
98     m_shiftKey = shiftKey;
99     m_altKey = altKey;
100     m_metaKey = metaKey;
101     m_altGraphKey = altGraphKey;
102 }
103
104 bool KeyboardEvent::getModifierState(const String& keyIdentifier) const
105 {
106     if (keyIdentifier == "Control")
107         return ctrlKey();
108     if (keyIdentifier == "Shift")
109         return shiftKey();
110     if (keyIdentifier == "Alt")
111         return altKey();
112     if (keyIdentifier == "Meta")
113         return metaKey();
114     return false;
115 }
116
117 int KeyboardEvent::keyCode() const
118 {
119     // IE: virtual key code for keyup/keydown, character code for keypress
120     // Firefox: virtual key code for keyup/keydown, zero for keypress
121     // We match IE.
122     if (!m_keyEvent)
123         return 0;
124     if (type() == eventNames().keydownEvent || type() == eventNames().keyupEvent)
125         return m_keyEvent->windowsVirtualKeyCode();
126     return charCode();
127 }
128
129 int KeyboardEvent::charCode() const
130 {
131     // IE: not supported
132     // Firefox: 0 for keydown/keyup events, character code for keypress
133     // We match Firefox, unless in backward compatibility mode, where we always return the character code.
134     bool backwardCompatibilityMode = false;
135     if (view() && view()->frame())
136         backwardCompatibilityMode = view()->frame()->eventHandler()->needsKeyboardEventDisambiguationQuirks();
137
138     if (!m_keyEvent || (type() != eventNames().keypressEvent && !backwardCompatibilityMode))
139         return 0;
140     String text = m_keyEvent->text();
141     return static_cast<int>(text.characterStartingAt(0));
142 }
143
144 const AtomicString& KeyboardEvent::interfaceName() const
145 {
146     return eventNames().interfaceForKeyboardEvent;
147 }
148
149 bool KeyboardEvent::isKeyboardEvent() const
150 {
151     return true;
152 }
153
154 int KeyboardEvent::which() const
155 {
156     // Netscape's "which" returns a virtual key code for keydown and keyup, and a character code for keypress.
157     // That's exactly what IE's "keyCode" returns. So they are the same for keyboard events.
158     return keyCode();
159 }
160
161 KeyboardEvent* findKeyboardEvent(Event* event)
162 {
163     for (Event* e = event; e; e = e->underlyingEvent())
164         if (e->isKeyboardEvent())
165             return static_cast<KeyboardEvent*>(e);
166     return 0;
167 }
168
169 PassRefPtr<KeyboardEventDispatchMediator> KeyboardEventDispatchMediator::create(PassRefPtr<KeyboardEvent> event)
170 {
171     return adoptRef(new KeyboardEventDispatchMediator(event));
172 }
173
174 KeyboardEventDispatchMediator::KeyboardEventDispatchMediator(PassRefPtr<KeyboardEvent> event)
175     : EventDispatchMediator(event)
176 {
177 }
178
179 bool KeyboardEventDispatchMediator::dispatchEvent(EventDispatcher* dispatcher) const
180 {
181     // Make sure not to return true if we already took default action while handling the event.
182     return EventDispatchMediator::dispatchEvent(dispatcher) && !event()->defaultHandled();
183 }
184
185 } // namespace WebCore