WebKit2PlatformKeyboardEvent(const WebKeyboardEvent& webEvent)
{
// PlatformEvent
switch (webEvent.type()) {
case WebEvent::KeyDown:
m_type = WebCore::PlatformEvent::KeyDown;
break;
case WebEvent::KeyUp:
m_type = WebCore::PlatformEvent::KeyUp;
break;
case WebEvent::RawKeyDown:
m_type = WebCore::PlatformEvent::RawKeyDown;
break;
case WebEvent::Char:
m_type = WebCore::PlatformEvent::Char;
break;
default:
ASSERT_NOT_REACHED();
}
m_modifiers = 0;
if (webEvent.shiftKey())
m_modifiers |= ShiftKey;
if (webEvent.controlKey())
m_modifiers |= CtrlKey;
if (webEvent.altKey())
m_modifiers |= AltKey;
if (webEvent.metaKey())
m_modifiers |= MetaKey;
m_timestamp = webEvent.timestamp();
// PlatformKeyboardEvent
m_text = webEvent.text();
m_unmodifiedText = webEvent.unmodifiedText();
m_keyIdentifier = webEvent.keyIdentifier();
m_windowsVirtualKeyCode = webEvent.windowsVirtualKeyCode();
m_nativeVirtualKeyCode = webEvent.nativeVirtualKeyCode();
m_macCharCode = webEvent.macCharCode();
#if USE(APPKIT) || PLATFORM(GTK)
m_handledByInputMethod = webEvent.handledByInputMethod();
m_commands = webEvent.commands();
#endif
m_autoRepeat = webEvent.isAutoRepeat();
m_isKeypad = webEvent.isKeypad();
m_isSystemKey = webEvent.isSystemKey();
}
WebKit2PlatformKeyboardEvent(const WebKeyboardEvent& webEvent)
{
switch (webEvent.type()) {
case WebEvent::KeyDown:
m_type = PlatformKeyboardEvent::KeyDown;
break;
case WebEvent::KeyUp:
m_type = PlatformKeyboardEvent::KeyUp;
break;
case WebEvent::RawKeyDown:
m_type = PlatformKeyboardEvent::RawKeyDown;
break;
case WebEvent::Char:
m_type = PlatformKeyboardEvent::Char;
break;
default:
ASSERT_NOT_REACHED();
}
m_text = webEvent.text();
m_unmodifiedText = webEvent.unmodifiedText();
m_keyIdentifier = webEvent.keyIdentifier();
m_windowsVirtualKeyCode = webEvent.windowsVirtualKeyCode();
m_nativeVirtualKeyCode = webEvent.nativeVirtualKeyCode();
m_autoRepeat = webEvent.isAutoRepeat();
m_isKeypad = webEvent.isKeypad();
m_shiftKey = webEvent.shiftKey();
m_ctrlKey = webEvent.controlKey();
m_altKey = webEvent.altKey();
m_metaKey = webEvent.metaKey();
#if PLATFORM(WIN)
// FIXME: We should make m_isSystemKey available (and false) on all platforms
// to avoid this #define.
m_isSystemKey = webEvent.isSystemKey();
#endif
}
void WebPage::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
{
if (messageID.is<CoreIPC::MessageClassDrawingArea>()) {
ASSERT(m_drawingArea);
m_drawingArea->didReceiveMessage(connection, messageID, arguments);
return;
}
switch (messageID.get<WebPageMessage::Kind>()) {
case WebPageMessage::SetActive: {
bool active;
if (!arguments.decode(active))
return;
setActive(active);
break;
}
case WebPageMessage::SetFocused: {
bool focused;
if (!arguments.decode(focused))
return;
setFocused(focused);
break;
}
case WebPageMessage::MouseEvent: {
WebMouseEvent event;
if (!arguments.decode(event))
return;
connection->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In((uint32_t)event.type()));
PlatformMouseEvent platformEvent = platform(event);
mouseEvent(platformEvent);
break;
}
case WebPageMessage::WheelEvent: {
WebWheelEvent event;
if (!arguments.decode(event))
return;
connection->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In((uint32_t)event.type()));
PlatformWheelEvent platformEvent = platform(event);
wheelEvent(platformEvent);
break;
}
case WebPageMessage::KeyEvent: {
WebKeyboardEvent event;
if (!arguments.decode(event))
return;
connection->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In((uint32_t)event.type()));
PlatformKeyboardEvent platformEvent = platform(event);
keyEvent(platformEvent);
break;
}
case WebPageMessage::LoadURL: {
String url;
if (!arguments.decode(url))
return;
loadURL(url);
break;
}
case WebPageMessage::StopLoading:
stopLoading();
break;
case WebPageMessage::Reload:
bool reloadFromOrigin;
if (!arguments.decode(CoreIPC::Out(reloadFromOrigin)))
return;
reload(reloadFromOrigin);
break;
case WebPageMessage::GoForward:
goForward();
break;
case WebPageMessage::GoBack:
goBack();
break;
case WebPageMessage::DidReceivePolicyDecision: {
uint64_t frameID;
uint64_t listenerID;
uint32_t policyAction;
if (!arguments.decode(CoreIPC::Out(frameID, listenerID, policyAction)))
return;
didReceivePolicyDecision(webFrame(frameID), listenerID, (WebCore::PolicyAction)policyAction);
break;
}
case WebPageMessage::RunJavaScriptInMainFrame: {
String script;
uint64_t callbackID;
if (!arguments.decode(CoreIPC::Out(script, callbackID)))
return;
runJavaScriptInMainFrame(script, callbackID);
break;
}
case WebPageMessage::GetRenderTreeExternalRepresentation: {
uint64_t callbackID;
if (!arguments.decode(callbackID))
return;
getRenderTreeExternalRepresentation(callbackID);
break;
}
case WebPageMessage::Close: {
close();
break;
}
case WebPageMessage::TryClose: {
tryClose();
break;
}
default:
ASSERT_NOT_REACHED();
break;
}
}
WebKeyboardEvent WebInputEventFactory::keyboardEvent(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam)
{
WebKeyboardEvent result;
// TODO(pkasting): http://b/1117926 Are we guaranteed that the message that
// GetMessageTime() refers to is the same one that we're passed in? Perhaps
// one of the construction parameters should be the time passed by the
// caller, who would know for sure.
result.timeStampSeconds = GetMessageTime() / 1000.0;
result.windowsKeyCode = result.nativeKeyCode = static_cast<int>(wparam);
switch (message) {
case WM_SYSKEYDOWN:
result.isSystemKey = true;
case WM_KEYDOWN:
result.type = WebInputEvent::RawKeyDown;
break;
case WM_SYSKEYUP:
result.isSystemKey = true;
case WM_KEYUP:
result.type = WebInputEvent::KeyUp;
break;
case WM_IME_CHAR:
result.type = WebInputEvent::Char;
break;
case WM_SYSCHAR:
result.isSystemKey = true;
result.type = WebInputEvent::Char;
case WM_CHAR:
result.type = WebInputEvent::Char;
break;
default:
ASSERT_NOT_REACHED();
}
if (result.type == WebInputEvent::Char || result.type == WebInputEvent::RawKeyDown) {
result.text[0] = result.windowsKeyCode;
result.unmodifiedText[0] = result.windowsKeyCode;
}
if (result.type != WebInputEvent::Char)
result.setKeyIdentifierFromWindowsKeyCode();
if (GetKeyState(VK_SHIFT) & 0x8000)
result.modifiers |= WebInputEvent::ShiftKey;
if (GetKeyState(VK_CONTROL) & 0x8000)
result.modifiers |= WebInputEvent::ControlKey;
if (GetKeyState(VK_MENU) & 0x8000)
result.modifiers |= WebInputEvent::AltKey;
// NOTE: There doesn't seem to be a way to query the mouse button state in
// this case.
if (LOWORD(lparam) > 1)
result.modifiers |= WebInputEvent::IsAutoRepeat;
if (isKeyPad(wparam, lparam))
result.modifiers |= WebInputEvent::IsKeyPad;
SetToggleKeyState(&result);
return result;
}
