Merge webkit.org at r58033 : Initial merge by git

Change-Id: If006c38561af287c50cd578d251629b51e4d8cd1

10 files changed, 638 insertions, 704 deletions

diff --git a/WebCore/platform/haiku/CursorHaiku.cpp b/WebCore/platform/haiku/CursorHaiku.cpp
index 7f010d5..21d678a 100644
--- a/WebCore/platform/haiku/CursorHaiku.cpp
+++ b/WebCore/platform/haiku/CursorHaiku.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * All rights reserved.
  *
@@ -30,9 +31,6 @@
 
 #include "NotImplemented.h"
 
-#include <app/AppDefs.h>
-
-
 namespace WebCore {
 
 Cursor::Cursor(PlatformCursor cursor)
@@ -41,196 +39,232 @@ Cursor::Cursor(PlatformCursor cursor)
 }
 
 Cursor::Cursor(const Cursor& other)
-    : m_impl(other.m_impl)
+    : m_impl(0)
 {
+    *this = other;
 }
 
 Cursor::~Cursor()
 {
+    delete m_impl;
 }
 
 Cursor::Cursor(Image*, const IntPoint&)
+    : m_impl(0)
 {
     notImplemented();
 }
 
 Cursor& Cursor::operator=(const Cursor& other)
 {
-    m_impl = other.m_impl;
+    delete m_impl;
+    m_impl = other.m_impl ? new BCursor(*other.m_impl) : 0;
     return *this;
 }
 
-static Cursor globalCursor = const_cast<BCursor*>(B_CURSOR_SYSTEM_DEFAULT);
-static Cursor ibeamCursor = const_cast<BCursor*>(B_CURSOR_I_BEAM);
+static Cursor createCursorByID(BCursorID id)
+{
+    return Cursor(new BCursor(id));
+}
 
 const Cursor& pointerCursor()
 {
-    return globalCursor;
+    static Cursor cursorSystemDefault(0);
+    return cursorSystemDefault;
 }
 
 const Cursor& moveCursor()
 {
-    return globalCursor;
+    static Cursor cursorMove = createCursorByID(B_CURSOR_ID_MOVE);
+    return cursorMove;
 }
 
 const Cursor& crossCursor()
 {
-    return globalCursor;
+    static Cursor cursorCrossHair = createCursorByID(B_CURSOR_ID_CROSS_HAIR);
+    return cursorCrossHair;
 }
 
 const Cursor& handCursor()
 {
-    return globalCursor;
+    static Cursor cursorFollowLink = createCursorByID(B_CURSOR_ID_FOLLOW_LINK);
+    return cursorFollowLink;
 }
 
 const Cursor& iBeamCursor()
 {
-    return ibeamCursor;
+    static Cursor cursorIBeam = createCursorByID(B_CURSOR_ID_I_BEAM);
+    return cursorIBeam;
 }
 
 const Cursor& waitCursor()
 {
-    return globalCursor;
+    static Cursor cursorProgress = createCursorByID(B_CURSOR_ID_PROGRESS);
+    return cursorProgress;
 }
 
 const Cursor& helpCursor()
 {
-    return globalCursor;
+    static Cursor cursorHelp = createCursorByID(B_CURSOR_ID_HELP);
+    return cursorHelp;
 }
 
 const Cursor& eastResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeEast = createCursorByID(B_CURSOR_ID_RESIZE_EAST);
+    return cursorResizeEast;
 }
 
 const Cursor& northResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeNorth = createCursorByID(B_CURSOR_ID_RESIZE_NORTH);
+    return cursorResizeNorth;
 }
 
 const Cursor& northEastResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeNorthEast = createCursorByID(B_CURSOR_ID_RESIZE_NORTH_EAST);
+    return cursorResizeNorthEast;
 }
 
 const Cursor& northWestResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeNorthWest = createCursorByID(B_CURSOR_ID_RESIZE_NORTH_WEST);
+    return cursorResizeNorthWest;
 }
 
 const Cursor& southResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeSouth = createCursorByID(B_CURSOR_ID_RESIZE_SOUTH);
+    return cursorResizeSouth;
 }
 
 const Cursor& southEastResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeSouthEast = createCursorByID(B_CURSOR_ID_RESIZE_SOUTH_EAST);
+    return cursorResizeSouthEast;
 }
 
 const Cursor& southWestResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeSouthWest = createCursorByID(B_CURSOR_ID_RESIZE_SOUTH_WEST);
+    return cursorResizeSouthWest;
 }
 
 const Cursor& westResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeWest = createCursorByID(B_CURSOR_ID_RESIZE_WEST);
+    return cursorResizeWest;
 }
 
 const Cursor& northSouthResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeNorthSouth = createCursorByID(B_CURSOR_ID_RESIZE_NORTH_SOUTH);
+    return cursorResizeNorthSouth;
 }
 
 const Cursor& eastWestResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeEastWest = createCursorByID(B_CURSOR_ID_RESIZE_EAST_WEST);
+    return cursorResizeEastWest;
 }
 
 const Cursor& northEastSouthWestResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeNorthEastSouthWest = createCursorByID(B_CURSOR_ID_RESIZE_NORTH_EAST_SOUTH_WEST);
+    return cursorResizeNorthEastSouthWest;
 }
 
 const Cursor& northWestSouthEastResizeCursor()
 {
-    return globalCursor;
+    static Cursor cursorResizeNorthWestSouthEast = createCursorByID(B_CURSOR_ID_RESIZE_NORTH_WEST_SOUTH_EAST);
+    return cursorResizeNorthWestSouthEast;
 }
 
 const Cursor& columnResizeCursor()
 {
-    return globalCursor;
+    return eastWestResizeCursor();
 }
 
 const Cursor& rowResizeCursor()
 {
-    return globalCursor;
+    return northSouthResizeCursor();
 }
 
 const Cursor& verticalTextCursor()
 {
-    return globalCursor;
+    static Cursor cursorIBeamHorizontal = createCursorByID(B_CURSOR_ID_I_BEAM_HORIZONTAL);
+    return cursorIBeamHorizontal;
 }
 
 const Cursor& cellCursor()
 {
-    return globalCursor;
+    return pointerCursor();
 }
 
 const Cursor& contextMenuCursor()
 {
-    return globalCursor;
+    static Cursor cursorContextMenu = createCursorByID(B_CURSOR_ID_CONTEXT_MENU);
+    return cursorContextMenu;
 }
 
 const Cursor& noDropCursor()
 {
-    return globalCursor;
+    static Cursor cursorNotAllowed = createCursorByID(B_CURSOR_ID_NOT_ALLOWED);
+    return cursorNotAllowed;
 }
 
 const Cursor& copyCursor()
 {
-    return globalCursor;
+    static Cursor cursorCopy = createCursorByID(B_CURSOR_ID_COPY);
+    return cursorCopy;
 }
 
 const Cursor& progressCursor()
 {
-    return globalCursor;
+    static Cursor cursorProgress = createCursorByID(B_CURSOR_ID_PROGRESS);
+    return cursorProgress;
 }
 
 const Cursor& aliasCursor()
 {
-    return globalCursor;
+    return handCursor();
 }
 
 const Cursor& noneCursor()
 {
-    return globalCursor;
+    static Cursor cursorNoCursor = createCursorByID(B_CURSOR_ID_NO_CURSOR);
+    return cursorNoCursor;
 }
 
 const Cursor& notAllowedCursor()
 {
-    return globalCursor;
+    static Cursor cursorNotAllowed = createCursorByID(B_CURSOR_ID_NOT_ALLOWED);
+    return cursorNotAllowed;
 }
 
 const Cursor& zoomInCursor()
 {
-    return globalCursor;
+    static Cursor cursorZoomIn = createCursorByID(B_CURSOR_ID_ZOOM_IN);
+    return cursorZoomIn;
 }
 
 const Cursor& zoomOutCursor()
 {
-    return globalCursor;
+    static Cursor cursorZoomOut = createCursorByID(B_CURSOR_ID_ZOOM_OUT);
+    return cursorZoomOut;
 }
 
 const Cursor& grabCursor()
 {
-    return globalCursor;
+    static Cursor cursorGrab = createCursorByID(B_CURSOR_ID_GRAB);
+    return cursorGrab;
 }
 
 const Cursor& grabbingCursor()
 {
-    return globalCursor;
+    static Cursor cursorGrabbing = createCursorByID(B_CURSOR_ID_GRABBING);
+    return cursorGrabbing;
 }
 
 } // namespace WebCore
diff --git a/WebCore/platform/haiku/FileSystemHaiku.cpp b/WebCore/platform/haiku/FileSystemHaiku.cpp
index 3d9161a..b0d34f2 100644
--- a/WebCore/platform/haiku/FileSystemHaiku.cpp
+++ b/WebCore/platform/haiku/FileSystemHaiku.cpp
@@ -29,9 +29,9 @@
 #include "config.h"
 #include "FileSystem.h"
 
-#include "CString.h"
 #include "NotImplemented.h"
 #include "PlatformString.h"
+#include <wtf/text/CString.h>
 
 #include <Directory.h>
 #include <Entry.h>
diff --git a/WebCore/platform/haiku/KeyboardCodes.h b/WebCore/platform/haiku/KeyboardCodes.h
deleted file mode 100644
index 6f0d490..0000000
--- a/WebCore/platform/haiku/KeyboardCodes.h
+++ /dev/null
@@ -1,544 +0,0 @@
-/*
- * Copyright (C) 2006 Michael Emmel mike.emmel@gmail.com 
- * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#ifndef KeyboardCodes_h
-#define KeyboardCodes_h
-
-
-namespace WebCore {
-    // VK_LBUTTON (01) Left mouse button
-    // VK_RBUTTON (02) Right mouse button
-    // VK_CANCEL (03) Control-break processing
-    // VK_MBUTTON (04) Middle mouse button (three-button mouse)
-    // VK_XBUTTON1 (05)
-    // VK_XBUTTON2 (06)
-
-    // VK_BACK (08) BACKSPACE key
-    const int VK_BACK = 0x08;
-
-    // VK_TAB (09) TAB key
-    const int VK_TAB = 0x09;
-
-    // VK_CLEAR (0C) CLEAR key
-    const int VK_CLEAR = 0x0C;
-
-    // VK_RETURN (0D)
-    const int VK_RETURN = 0x0D;
-
-    // VK_SHIFT (10) SHIFT key
-    const int VK_SHIFT = 0x10;
-
-    // VK_CONTROL (11) CTRL key
-    const int VK_CONTROL = 0x11;
-
-    // VK_MENU (12) ALT key
-    const int VK_MENU = 0x12;
-
-    // VK_PAUSE (13) PAUSE key
-    const int VK_PAUSE = 0x13;
-
-    // VK_CAPITAL (14) CAPS LOCK key
-    const int VK_CAPITAL = 0x14;
-
-    // VK_KANA (15) Input Method Editor (IME) Kana mode
-    const int VK_KANA = 0x15;
-
-    // VK_HANGUEL (15) IME Hanguel mode (maintained for compatibility; use VK_HANGUL)
-    // VK_HANGUL (15) IME Hangul mode
-    const int VK_HANGUL = 0x15;
-
-    // VK_JUNJA (17) IME Junja mode
-    const int VK_JUNJA = 0x17;
-
-    // VK_FINAL (18) IME final mode
-    const int VK_FINAL = 0x18;
-
-    // VK_HANJA (19) IME Hanja mode
-    const int VK_HANJA = 0x19;
-
-    // VK_KANJI (19) IME Kanji mode
-    const int VK_KANJI = 0x19;
-
-    // VK_ESCAPE (1B) ESC key
-    const int VK_ESCAPE = 0x1B;
-
-    // VK_CONVERT (1C) IME convert
-    const int VK_CONVERT = 0x1C;
-
-    // VK_NONCONVERT (1D) IME nonconvert
-    const int VK_NONCONVERT = 0x1D;
-
-    // VK_ACCEPT (1E) IME accept
-    const int VK_ACCEPT = 0x1E;
-
-    // VK_MODECHANGE (1F) IME mode change request
-    const int VK_MODECHANGE = 0x1F;
-
-    // VK_SPACE (20) SPACEBAR
-    const int VK_SPACE = 0x20;
-
-    // VK_PRIOR (21) PAGE UP key
-    const int VK_PRIOR = 0x21;
-
-    // VK_NEXT (22) PAGE DOWN key
-    const int VK_NEXT = 0x22;
-
-    // VK_END (23) END key
-    const int VK_END = 0x23;
-
-    // VK_HOME (24) HOME key
-    const int VK_HOME = 0x24;
-
-    // VK_LEFT (25) LEFT ARROW key
-    const int VK_LEFT = 0x25;
-
-    // VK_UP (26) UP ARROW key
-    const int VK_UP = 0x26;
-
-    // VK_RIGHT (27) RIGHT ARROW key
-    const int VK_RIGHT = 0x27;
-
-    // VK_DOWN (28) DOWN ARROW key
-    const int VK_DOWN = 0x28;
-
-    // VK_SELECT (29) SELECT key
-    const int VK_SELECT = 0x29;
-
-    // VK_PRINT (2A) PRINT key
-    const int VK_PRINT = 0x2A;
-
-    // VK_EXECUTE (2B) EXECUTE key
-    const int VK_EXECUTE = 0x2B;
-
-    // VK_SNAPSHOT (2C) PRINT SCREEN key
-    const int VK_SNAPSHOT = 0x2C;
-
-    // VK_INSERT (2D) INS key
-    const int VK_INSERT = 0x2D;
-
-    // VK_DELETE (2E) DEL key
-    const int VK_DELETE = 0x2E;
-
-    // VK_HELP (2F) HELP key
-    const int VK_HELP = 0x2F;
-
-    // (30) 0 key
-    const int VK_0 = 0x30;
-
-    // (31) 1 key
-    const int VK_1 = 0x31;
-
-    // (32) 2 key
-    const int VK_2 = 0x32;
-
-    // (33) 3 key
-    const int VK_3 = 0x33;
-
-    // (34) 4 key
-    const int VK_4 = 0x34;
-
-    // (35) 5 key;
-
-    const int VK_5 = 0x35;
-
-    // (36) 6 key
-    const int VK_6 = 0x36;
-
-    // (37) 7 key
-    const int VK_7 = 0x37;
-
-    // (38) 8 key
-    const int VK_8 = 0x38;
-
-    // (39) 9 key
-    const int VK_9 = 0x39;
-
-    // (41) A key
-    const int VK_A = 0x41;
-
-    // (42) B key
-    const int VK_B = 0x42;
-
-    // (43) C key
-    const int VK_C = 0x43;
-
-    // (44) D key
-    const int VK_D = 0x44;
-
-    // (45) E key
-    const int VK_E = 0x45;
-
-    // (46) F key
-    const int VK_F = 0x46;
-
-    // (47) G key
-    const int VK_G = 0x47;
-
-    // (48) H key
-    const int VK_H = 0x48;
-
-    // (49) I key
-    const int VK_I = 0x49;
-
-    // (4A) J key
-    const int VK_J = 0x4A;
-
-    // (4B) K key
-    const int VK_K = 0x4B;
-
-    // (4C) L key
-    const int VK_L = 0x4C;
-
-    // (4D) M key
-    const int VK_M = 0x4D;
-
-    // (4E) N key
-    const int VK_N = 0x4E;
-
-    // (4F) O key
-    const int VK_O = 0x4F;
-
-    // (50) P key
-    const int VK_P = 0x50;
-
-    // (51) Q key
-    const int VK_Q = 0x51;
-
-    // (52) R key
-    const int VK_R = 0x52;
-
-    // (53) S key
-    const int VK_S = 0x53;
-
-    // (54) T key
-    const int VK_T = 0x54;
-
-    // (55) U key
-    const int VK_U = 0x55;
-
-    // (56) V key
-    const int VK_V = 0x56;
-
-    // (57) W key
-    const int VK_W = 0x57;
-
-    // (58) X key
-    const int VK_X = 0x58;
-
-    // (59) Y key
-    const int VK_Y = 0x59;
-
-    // (5A) Z key
-    const int VK_Z = 0x5A;
-
-    // VK_LWIN (5B) Left Windows key (Microsoft Natural keyboard)
-    const int VK_LWIN = 0x5B;
-
-    // VK_RWIN (5C) Right Windows key (Natural keyboard)
-    const int VK_RWIN = 0x5C;
-
-    // VK_APPS (5D) Applications key (Natural keyboard)
-    const int VK_APPS = 0x5D;
-
-    // VK_SLEEP (5F) Computer Sleep key
-    const int VK_SLEEP = 0x5F;
-
-    // VK_NUMPAD0 (60) Numeric keypad 0 key
-    const int VK_NUMPAD0 = 0x60;
-
-    // VK_NUMPAD1 (61) Numeric keypad 1 key
-    const int VK_NUMPAD1 = 0x61;
-
-    // VK_NUMPAD2 (62) Numeric keypad 2 key
-    const int VK_NUMPAD2 = 0x62;
-
-    // VK_NUMPAD3 (63) Numeric keypad 3 key
-    const int VK_NUMPAD3 = 0x63;
-
-    // VK_NUMPAD4 (64) Numeric keypad 4 key
-    const int VK_NUMPAD4 = 0x64;
-
-    // VK_NUMPAD5 (65) Numeric keypad 5 key
-    const int VK_NUMPAD5 = 0x65;
-
-    // VK_NUMPAD6 (66) Numeric keypad 6 key
-    const int VK_NUMPAD6 = 0x66;
-
-    // VK_NUMPAD7 (67) Numeric keypad 7 key
-    const int VK_NUMPAD7 = 0x67;
-
-    // VK_NUMPAD8 (68) Numeric keypad 8 key
-    const int VK_NUMPAD8 = 0x68;
-
-    // VK_NUMPAD9 (69) Numeric keypad 9 key
-    const int VK_NUMPAD9 = 0x69;
-
-    // VK_MULTIPLY (6A) Multiply key
-    const int VK_MULTIPLY = 0x6A;
-
-    // VK_ADD (6B) Add key
-    const int VK_ADD = 0x6B;
-
-    // VK_SEPARATOR (6C) Separator key
-    const int VK_SEPARATOR = 0x6C;
-
-    // VK_SUBTRACT (6D) Subtract key
-    const int VK_SUBTRACT = 0x6D;
-
-    // VK_DECIMAL (6E) Decimal key
-    const int VK_DECIMAL = 0x6E;
-
-    // VK_DIVIDE (6F) Divide key
-    const int VK_DIVIDE = 0x6F;
-
-    // VK_F1 (70) F1 key
-    const int VK_F1 = 0x70;
-
-    // VK_F2 (71) F2 key
-    const int VK_F2 = 0x71;
-
-    // VK_F3 (72) F3 key
-    const int VK_F3 = 0x72;
-
-    // VK_F4 (73) F4 key
-    const int VK_F4 = 0x73;
-
-    // VK_F5 (74) F5 key
-    const int VK_F5 = 0x74;
-
-    // VK_F6 (75) F6 key
-    const int VK_F6 = 0x75;
-
-    // VK_F7 (76) F7 key
-    const int VK_F7 = 0x76;
-
-    // VK_F8 (77) F8 key
-    const int VK_F8 = 0x77;
-
-    // VK_F9 (78) F9 key
-    const int VK_F9 = 0x78;
-
-    // VK_F10 (79) F10 key
-    const int VK_F10 = 0x79;
-
-    // VK_F11 (7A) F11 key
-    const int VK_F11 = 0x7A;
-
-    // VK_F12 (7B) F12 key
-    const int VK_F12 = 0x7B;
-
-    // VK_F13 (7C) F13 key
-    const int VK_F13 = 0x7C;
-
-    // VK_F14 (7D) F14 key
-    const int VK_F14 = 0x7D;
-
-    // VK_F15 (7E) F15 key
-    const int VK_F15 = 0x7E;
-
-    // VK_F16 (7F) F16 key
-    const int VK_F16 = 0x7F;
-
-    // VK_F17 (80H) F17 key
-    const int VK_F17 = 0x80;
-
-    // VK_F18 (81H) F18 key
-    const int VK_F18 = 0x81;
-
-    // VK_F19 (82H) F19 key
-    const int VK_F19 = 0x82;
-
-    // VK_F20 (83H) F20 key
-    const int VK_F20 = 0x83;
-
-    // VK_F21 (84H) F21 key
-    const int VK_F21 = 0x84;
-
-    // VK_F22 (85H) F22 key
-    const int VK_F22 = 0x85;
-
-    // VK_F23 (86H) F23 key
-    const int VK_F23 = 0x86;
-
-    // VK_F24 (87H) F24 key
-    const int VK_F24 = 0x87;
-
-    // VK_NUMLOCK (90) NUM LOCK key
-    const int VK_NUMLOCK = 0x90;
-
-    // VK_SCROLL (91) SCROLL LOCK key
-    const int VK_SCROLL = 0x91;
-
-    // VK_LSHIFT (A0) Left SHIFT key
-    const int VK_LSHIFT = 0xA0;
-
-    // VK_RSHIFT (A1) Right SHIFT key
-    const int VK_RSHIFT = 0xA1;
-
-    // VK_LCONTROL (A2) Left CONTROL key
-    const int VK_LCONTROL = 0xA2;
-
-    // VK_RCONTROL (A3) Right CONTROL key
-    const int VK_RCONTROL = 0xA3;
-
-    // VK_LMENU (A4) Left MENU key
-    const int VK_LMENU = 0xA4;
-
-    // VK_RMENU (A5) Right MENU key
-    const int VK_RMENU = 0xA5;
-
-    // VK_BROWSER_BACK (A6) Windows 2000/XP: Browser Back key
-    const int VK_BROWSER_BACK = 0xA6;
-
-    // VK_BROWSER_FORWARD (A7) Windows 2000/XP: Browser Forward key
-    const int VK_BROWSER_FORWARD = 0xA7;
-
-    // VK_BROWSER_REFRESH (A8) Windows 2000/XP: Browser Refresh key
-    const int VK_BROWSER_REFRESH = 0xA8;
-
-    // VK_BROWSER_STOP (A9) Windows 2000/XP: Browser Stop key
-    const int VK_BROWSER_STOP = 0xA9;
-
-    // VK_BROWSER_SEARCH (AA) Windows 2000/XP: Browser Search key
-    const int VK_BROWSER_SEARCH = 0xAA;
-
-    // VK_BROWSER_FAVORITES (AB) Windows 2000/XP: Browser Favorites key
-    const int VK_BROWSER_FAVORITES = 0xAB;
-
-    // VK_BROWSER_HOME (AC) Windows 2000/XP: Browser Start and Home key
-    const int VK_BROWSER_HOME = 0xAC;
-
-    // VK_VOLUME_MUTE (AD) Windows 2000/XP: Volume Mute key
-    const int VK_VOLUME_MUTE = 0xAD;
-
-    // VK_VOLUME_DOWN (AE) Windows 2000/XP: Volume Down key
-    const int VK_VOLUME_DOWN = 0xAE;
-
-    // VK_VOLUME_UP (AF) Windows 2000/XP: Volume Up key
-    const int VK_VOLUME_UP = 0xAF;
-
-    // VK_MEDIA_NEXT_TRACK (B0) Windows 2000/XP: Next Track key
-    const int VK_MEDIA_NEXT_TRACK = 0xB0;
-
-    // VK_MEDIA_PREV_TRACK (B1) Windows 2000/XP: Previous Track key
-    const int VK_MEDIA_PREV_TRACK = 0xB1;
-
-    // VK_MEDIA_STOP (B2) Windows 2000/XP: Stop Media key
-    const int VK_MEDIA_STOP = 0xB2;
-
-    // VK_MEDIA_PLAY_PAUSE (B3) Windows 2000/XP: Play/Pause Media key
-    const int VK_MEDIA_PLAY_PAUSE = 0xB3;
-
-    // VK_LAUNCH_MAIL (B4) Windows 2000/XP: Start Mail key
-    const int VK_MEDIA_LAUNCH_MAIL = 0xB4;
-
-    // VK_LAUNCH_MEDIA_SELECT (B5) Windows 2000/XP: Select Media key
-    const int VK_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5;
-
-    // VK_LAUNCH_APP1 (B6) Windows 2000/XP: Start Application 1 key
-    const int VK_MEDIA_LAUNCH_APP1 = 0xB6;
-
-    // VK_LAUNCH_APP2 (B7) Windows 2000/XP: Start Application 2 key
-    const int VK_MEDIA_LAUNCH_APP2 = 0xB7;
-
-    // VK_OEM_1 (BA) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ';:' key
-    const int VK_OEM_1 = 0xBA;
-
-    // VK_OEM_PLUS (BB) Windows 2000/XP: For any country/region, the '+' key
-    const int VK_OEM_PLUS = 0xBB;
-
-    // VK_OEM_COMMA (BC) Windows 2000/XP: For any country/region, the ',' key
-    const int VK_OEM_COMMA = 0xBC;
-
-    // VK_OEM_MINUS (BD) Windows 2000/XP: For any country/region, the '-' key
-    const int VK_OEM_MINUS = 0xBD;
-
-    // VK_OEM_PERIOD (BE) Windows 2000/XP: For any country/region, the '.' key
-    const int VK_OEM_PERIOD = 0xBE;
-
-    // VK_OEM_2 (BF) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '/?' key
-    const int VK_OEM_2 = 0xBF;
-
-    // VK_OEM_3 (C0) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '`~' key
-    const int VK_OEM_3 = 0xC0;
-
-    // VK_OEM_4 (DB) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '[{' key
-    const int VK_OEM_4 = 0xDB;
-
-    // VK_OEM_5 (DC) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the '\|' key
-    const int VK_OEM_5 = 0xDC;
-
-    // VK_OEM_6 (DD) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the ']}' key
-    const int VK_OEM_6 = 0xDD;
-
-    // VK_OEM_7 (DE) Used for miscellaneous characters; it can vary by keyboard. Windows 2000/XP: For the US standard keyboard, the 'single-quote/double-quote' key
-    const int VK_OEM_7 = 0xDE;
-
-    // VK_OEM_8 (DF) Used for miscellaneous characters; it can vary by keyboard.
-    const int VK_OEM_8 = 0xDF;
-
-    // VK_OEM_102 (E2) Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard
-    const int VK_OEM_102 = 0xE2;
-
-    // VK_PROCESSKEY (E5) Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key
-    const int VK_PROCESSKEY = 0xE5;
-
-    // VK_PACKET (E7) Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes. The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, see Remark in KEYBDINPUT,SendInput, WM_KEYDOWN, and WM_KEYUP
-    const int VK_PACKET = 0xE7;
-
-    // VK_ATTN (F6) Attn key
-    const int VK_ATTN = 0xF6;
-
-    // VK_CRSEL (F7) CrSel key
-    const int VK_CRSEL = 0xF7;
-
-    // VK_EXSEL (F8) ExSel key
-    const int VK_EXSEL = 0xF8;
-
-    // VK_EREOF (F9) Erase EOF key
-    const int VK_EREOF = 0xF9;
-
-    // VK_PLAY (FA) Play key
-    const int VK_PLAY = 0xFA;
-
-    // VK_ZOOM (FB) Zoom key
-    const int VK_ZOOM = 0xFB;
-
-    // VK_NONAME (FC) Reserved for future use
-    const int VK_NONAME = 0xFC;
-
-    // VK_PA1 (FD) PA1 key
-    const int VK_PA1 = 0xFD;
-
-    // VK_OEM_CLEAR (FE) Clear key
-    const int VK_OEM_CLEAR = 0xFE;
-
-    const int VK_UNKNOWN = 0;
-} // namespace WebCore
-
-#endif // KeyboardCodes_h
diff --git a/WebCore/platform/haiku/MIMETypeRegistryHaiku.cpp b/WebCore/platform/haiku/MIMETypeRegistryHaiku.cpp
index 59ae19a..685827e 100644
--- a/WebCore/platform/haiku/MIMETypeRegistryHaiku.cpp
+++ b/WebCore/platform/haiku/MIMETypeRegistryHaiku.cpp
@@ -2,6 +2,7 @@
  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2007 Trolltech ASA
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -29,7 +30,8 @@
 #include "MIMETypeRegistry.h"
 
 #include "PlatformString.h"
-
+#include <MimeType.h>
+#include <wtf/text/CString.h>
 
 namespace WebCore {
 struct ExtensionMap {
@@ -37,11 +39,11 @@ struct ExtensionMap {
     const char* mimeType;
 };
 
-static const ExtensionMap extensionMap [] = {
+static const ExtensionMap extensionMap[] = {
     { "bmp", "image/bmp" },
     { "gif", "image/gif" },
     { "html", "text/html" },
-    { "ico", "image/x-icon" },   
+    { "ico", "image/x-icon" },
     { "jpeg", "image/jpeg" },
     { "jpg", "image/jpeg" },
     { "js", "application/x-javascript" },
@@ -58,18 +60,34 @@ static const ExtensionMap extensionMap [] = {
     { 0, 0 }
 };
 
-// FIXME: Use the Haiku MIME registry
-String MIMETypeRegistry::getMIMETypeForExtension(const String &ext)
+String MIMETypeRegistry::getMIMETypeForExtension(const String& ext)
 {
     String str = ext.lower();
-    const ExtensionMap *extMap = extensionMap;
+
+    // Try WebCore built-in types.
+    const ExtensionMap* extMap = extensionMap;
     while (extMap->extension) {
         if (str == extMap->extension)
             return extMap->mimeType;
         ++extMap;
     }
-    // unknown, let's just assume plain text
-    return "text/plain";
+
+    // Try system mime database.
+    String fakeFileName("filename.");
+    fakeFileName.append(str);
+
+    BMimeType type;
+    if (BMimeType::GuessMimeType(fakeFileName.utf8().data(), &type) == B_OK)
+        return type.Type();
+
+    // unknown
+    return String();
 }
+
+bool MIMETypeRegistry::isApplicationPluginMIMEType(const String&)
+{
+    return false;
+}
+
 } // namespace WebCore
 
diff --git a/WebCore/platform/haiku/PasteboardHaiku.cpp b/WebCore/platform/haiku/PasteboardHaiku.cpp
index 8ad72ca..defec3f 100644
--- a/WebCore/platform/haiku/PasteboardHaiku.cpp
+++ b/WebCore/platform/haiku/PasteboardHaiku.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -21,7 +22,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -32,11 +33,13 @@
 #include "Frame.h"
 #include "KURL.h"
 #include "NotImplemented.h"
+#include "TextResourceDecoder.h"
 #include "markup.h"
 #include <support/Locker.h>
 #include <Clipboard.h>
 #include <Message.h>
 #include <String.h>
+#include <wtf/text/CString.h>
 
 
 namespace WebCore {
@@ -45,44 +48,80 @@ Pasteboard::Pasteboard()
 {
 }
 
+Pasteboard::~Pasteboard()
+{
+}
+
 Pasteboard* Pasteboard::generalPasteboard()
 {
-    static Pasteboard* pasteboard = new Pasteboard();
-    return pasteboard;
+    static Pasteboard pasteboard;
+    return &pasteboard;
 }
 
+// BClipboard unfortunately does not derive from BLocker, so we cannot use BAutolock.
+class AutoClipboardLocker {
+public:
+    AutoClipboardLocker(BClipboard* clipboard)
+        : m_clipboard(clipboard)
+        , m_isLocked(clipboard && clipboard->Lock())
+    {
+    }
+
+    ~AutoClipboardLocker()
+    {
+        if (m_isLocked)
+            m_clipboard->Unlock();
+    }
+
+    bool isLocked() const
+    {
+        return m_isLocked;
+    }
+
+private:
+    BClipboard* m_clipboard;
+    bool m_isLocked;
+};
+
 void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete, Frame* frame)
 {
-    BClipboard clipboard("WebKit");
-    if (!clipboard.Lock())
+    AutoClipboardLocker locker(be_clipboard);
+    if (!locker.isLocked())
         return;
 
-    clipboard.Clear();
-    BMessage* data = clipboard.Data();
+    be_clipboard->Clear();
+    BMessage* data = be_clipboard->Data();
     if (!data)
         return;
 
-    data->AddString("text/plain", BString(frame->selectedText()));
-    clipboard.Commit();
+    BString string(frame->selectedText());
 
-    clipboard.Unlock();
+    // Replace unwanted representation of blank lines
+    const char* utf8BlankLine = "\302\240\n";
+    string.ReplaceAll(utf8BlankLine, "\n");
+
+    data->AddData("text/plain", B_MIME_TYPE, string.String(), string.Length());
+
+    BString markupString(createMarkup(selectedRange, 0, AnnotateForInterchange));
+    data->AddData("text/html", B_MIME_TYPE, markupString.String(), markupString.Length());
+
+    be_clipboard->Commit();
 }
 
 void Pasteboard::writePlainText(const String& text)
 {
-    BClipboard clipboard("WebKit");
-    if (!clipboard.Lock())
+    AutoClipboardLocker locker(be_clipboard);
+    if (!locker.isLocked())
         return;
 
-    clipboard.Clear();
-    BMessage* data = clipboard.Data();
+    be_clipboard->Clear();
+    BMessage* data = be_clipboard->Data();
     if (!data)
         return;
 
-    data->AddString("text/plain", BString(text));
-    clipboard.Commit();
-
-    clipboard.Unlock();
+    BString string(text);
+    data->AddData("text/plain", B_MIME_TYPE, string.String(), string.Length());
+    be_clipboard->Commit();
 }
 
 bool Pasteboard::canSmartReplace()
@@ -93,18 +132,19 @@ bool Pasteboard::canSmartReplace()
 
 String Pasteboard::plainText(Frame* frame)
 {
-    BClipboard clipboard("WebKit");
-    if (!clipboard.Lock())
+    AutoClipboardLocker locker(be_clipboard);
+    if (!locker.isLocked())
         return String();
 
-    BMessage* data = clipboard.Data();
+    BMessage* data = be_clipboard->Data();
     if (!data)
         return String();
 
+    const char* buffer = 0;
+    ssize_t bufferLength;
     BString string;
-    data->FindString("text/plain", &string);
-
-    clipboard.Unlock();
+    if (data->FindData("text/plain", B_MIME_TYPE, reinterpret_cast<const void**>(&buffer), &bufferLength) == B_OK)
+        string.Append(buffer, bufferLength);
 
     return string;
 }
@@ -112,26 +152,60 @@ String Pasteboard::plainText(Frame* frame)
 PassRefPtr<DocumentFragment> Pasteboard::documentFragment(Frame* frame, PassRefPtr<Range> context,
                                                           bool allowPlainText, bool& chosePlainText)
 {
-    notImplemented();
+    chosePlainText = false;
+
+    AutoClipboardLocker locker(be_clipboard);
+    if (!locker.isLocked())
+        return 0;
+
+    BMessage* data = be_clipboard->Data();
+    if (!data)
+        return 0;
+
+    const char* buffer = 0;
+    ssize_t bufferLength;
+    if (data->FindData("text/html", B_MIME_TYPE, reinterpret_cast<const void**>(&buffer), &bufferLength) == B_OK) {
+        RefPtr<TextResourceDecoder> decoder = TextResourceDecoder::create("text/plain", "UTF-8", true);
+        String html = decoder->decode(buffer, bufferLength);
+        html += decoder->flush();
+
+        if (!html.isEmpty()) {
+            RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(frame->document(), html, "", FragmentScriptingNotAllowed);
+            if (fragment)
+                return fragment.release();
+        }
+    }
+
+    if (!allowPlainText)
+        return 0;
+
+    if (data->FindData("text/plain", B_MIME_TYPE, reinterpret_cast<const void**>(&buffer), &bufferLength) == B_OK) {
+        BString plainText(buffer, bufferLength);
+
+        chosePlainText = true;
+        RefPtr<DocumentFragment> fragment = createFragmentFromText(context.get(), plainText);
+        if (fragment)
+            return fragment.release();
+    }
+
     return 0;
 }
 
 void Pasteboard::writeURL(const KURL& url, const String&, Frame*)
 {
-    BClipboard clipboard("WebKit");
-    if (!clipboard.Lock())
+    AutoClipboardLocker locker(be_clipboard);
+    if (!locker.isLocked())
         return;
 
-    clipboard.Clear();
+    be_clipboard->Clear();
 
-    BMessage* data = clipboard.Data();
+    BMessage* data = be_clipboard->Data();
     if (!data)
         return;
 
-    data->AddString("text/plain", url.string());
-    clipboard.Commit();
-
-    clipboard.Unlock();
+    BString string(url.string());
+    data->AddData("text/plain", B_MIME_TYPE, string.String(), string.Length());
+    be_clipboard->Commit();
 }
 
 void Pasteboard::writeImage(Node*, const KURL&, const String&)
@@ -141,14 +215,12 @@ void Pasteboard::writeImage(Node*, const KURL&, const String&)
 
 void Pasteboard::clear()
 {
-    BClipboard clipboard("WebKit");
-    if (!clipboard.Lock())
+    AutoClipboardLocker locker(be_clipboard);
+    if (!locker.isLocked())
         return;
 
-    clipboard.Clear();
-    clipboard.Commit();
-
-    clipboard.Unlock();
+    be_clipboard->Clear();
+    be_clipboard->Commit();
 }
 
 } // namespace WebCore
diff --git a/WebCore/platform/haiku/PlatformKeyboardEventHaiku.cpp b/WebCore/platform/haiku/PlatformKeyboardEventHaiku.cpp
index 1545dfb..ecf5921 100644
--- a/WebCore/platform/haiku/PlatformKeyboardEventHaiku.cpp
+++ b/WebCore/platform/haiku/PlatformKeyboardEventHaiku.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
  * Copyright (C) 2008 Andrea Anzani <andrea.anzani@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * All rights reserved.
  *
@@ -29,11 +30,12 @@
 #include "config.h"
 #include "PlatformKeyboardEvent.h"
 
-#include "KeyboardCodes.h"
 #include "NotImplemented.h"
+#include "WindowsKeyboardCodes.h"
 #include <InterfaceDefs.h>
 #include <Message.h>
 #include <String.h>
+#include <wtf/text/CString.h>
 
 
 namespace WebCore {
@@ -78,7 +80,7 @@ static String keyIdentifierForHaikuKeyCode(char singleByte, int keyCode)
         break;
 
     case B_BACKSPACE:
-        return "U+0009";
+        return "U+0008";
     case B_LEFT_ARROW:
         return "Left";
     case B_RIGHT_ARROW:
@@ -105,12 +107,47 @@ static String keyIdentifierForHaikuKeyCode(char singleByte, int keyCode)
         return "U+0009";
     }
 
-    return String::format("U+%04X", toASCIIUpper(keyCode));
+    return String::format("U+%04X", toASCIIUpper(singleByte));
 }
 
-static int windowsKeyCodeForKeyEvent(char singleByte)
+static int windowsKeyCodeForKeyEvent(char singleByte, int keyCode)
 {
     switch (singleByte) {
+    case B_FUNCTION_KEY:
+        switch (keyCode) {
+        case B_F1_KEY:
+            return VK_F1;
+        case B_F2_KEY:
+            return VK_F2;
+        case B_F3_KEY:
+            return VK_F3;
+        case B_F4_KEY:
+            return VK_F4;
+        case B_F5_KEY:
+            return VK_F5;
+        case B_F6_KEY:
+            return VK_F6;
+        case B_F7_KEY:
+            return VK_F7;
+        case B_F8_KEY:
+            return VK_F8;
+        case B_F9_KEY:
+            return VK_F9;
+        case B_F10_KEY:
+            return VK_F10;
+        case B_F11_KEY:
+            return VK_F11;
+        case B_F12_KEY:
+            return VK_F12;
+        case B_PRINT_KEY:
+            return VK_PRINT;
+        case B_PAUSE_KEY:
+            return 0; // FIXME
+        case B_SCROLL_KEY:
+            return 0; // FIXME
+        }
+        break;
+
     case B_BACKSPACE:
         return VK_BACK; // (08) BACKSPACE key
     case B_TAB:
@@ -141,39 +178,191 @@ static int windowsKeyCodeForKeyEvent(char singleByte)
         return VK_INSERT; // (2D) INS key
     case B_DELETE:
         return VK_DELETE; // (2E) DEL key
-    case 0x2e:
-    default:
-        return 0;
+
+    case '0':
+    case ')':
+        return VK_0;
+    case '1':
+    case '!':
+        return VK_1;
+    case '2':
+    case '@':
+        return VK_2;
+    case '3':
+    case '#':
+        return VK_3;
+    case '4':
+    case '$':
+        return VK_4;
+    case '5':
+    case '%':
+        return VK_5;
+    case '6':
+    case '^':
+        return VK_6;
+    case '7':
+    case '&':
+        return VK_7;
+    case '8':
+    case '*':
+        return VK_8;
+    case '9':
+    case '(':
+        return VK_9;
+    case 'a':
+    case 'A':
+        return VK_A;
+    case 'b':
+    case 'B':
+        return VK_B;
+    case 'c':
+    case 'C':
+        return VK_C;
+    case 'd':
+    case 'D':
+        return VK_D;
+    case 'e':
+    case 'E':
+        return VK_E;
+    case 'f':
+    case 'F':
+        return VK_F;
+    case 'g':
+    case 'G':
+        return VK_G;
+    case 'h':
+    case 'H':
+        return VK_H;
+    case 'i':
+    case 'I':
+        return VK_I;
+    case 'j':
+    case 'J':
+        return VK_J;
+    case 'k':
+    case 'K':
+        return VK_K;
+    case 'l':
+    case 'L':
+        return VK_L;
+    case 'm':
+    case 'M':
+        return VK_M;
+    case 'n':
+    case 'N':
+        return VK_N;
+    case 'o':
+    case 'O':
+        return VK_O;
+    case 'p':
+    case 'P':
+        return VK_P;
+    case 'q':
+    case 'Q':
+        return VK_Q;
+    case 'r':
+    case 'R':
+        return VK_R;
+    case 's':
+    case 'S':
+        return VK_S;
+    case 't':
+    case 'T':
+        return VK_T;
+    case 'u':
+    case 'U':
+        return VK_U;
+    case 'v':
+    case 'V':
+        return VK_V;
+    case 'w':
+    case 'W':
+        return VK_W;
+    case 'x':
+    case 'X':
+        return VK_X;
+    case 'y':
+    case 'Y':
+        return VK_Y;
+    case 'z':
+    case 'Z':
+        return VK_Z;
+    case ';':
+    case ':':
+        return VK_OEM_1;
+    case '+':
+    case '=':
+        return VK_OEM_PLUS;
+    case ',':
+    case '<':
+        return VK_OEM_COMMA;
+    case '-':
+    case '_':
+        return VK_OEM_MINUS;
+    case '.':
+    case '>':
+        return VK_OEM_PERIOD;
+    case '/':
+    case '?':
+        return VK_OEM_2;
+    case '`':
+    case '~':
+        return VK_OEM_3;
+    case '[':
+    case '{':
+        return VK_OEM_4;
+    case '\\':
+    case '|':
+        return VK_OEM_5;
+    case ']':
+    case '}':
+        return VK_OEM_6;
+    case '\'':
+    case '"':
+        return VK_OEM_7;
     }
+    return singleByte;
 }
 
 PlatformKeyboardEvent::PlatformKeyboardEvent(BMessage* message)
     : m_autoRepeat(false)
+    , m_isKeypad(false)
+    , m_shiftKey(false)
     , m_ctrlKey(false)
     , m_altKey(false)
     , m_metaKey(false)
-    , m_isKeypad(false)
-    , m_shiftKey(false)
 {
     BString bytes = message->FindString("bytes");
 
+    m_nativeVirtualKeyCode = message->FindInt32("key");
+
     m_text = String::fromUTF8(bytes.String(), bytes.Length());
     m_unmodifiedText = String(bytes.String(), bytes.Length());
-    m_keyIdentifier = keyIdentifierForHaikuKeyCode(bytes.ByteAt(0), message->FindInt32("key"));
+    m_keyIdentifier = keyIdentifierForHaikuKeyCode(bytes.ByteAt(0), m_nativeVirtualKeyCode);
+
+    m_windowsVirtualKeyCode = windowsKeyCodeForKeyEvent(bytes.ByteAt(0), m_nativeVirtualKeyCode);
 
     if (message->what == B_KEY_UP)
         m_type = KeyUp;
     else if (message->what == B_KEY_DOWN)
         m_type = KeyDown;
 
-    m_windowsVirtualKeyCode = windowsKeyCodeForKeyEvent(bytes.ByteAt(0));
+    int32 modifiers = message->FindInt32("modifiers");
+    m_shiftKey = modifiers & B_SHIFT_KEY;
+    m_ctrlKey = modifiers & B_COMMAND_KEY;
+    m_altKey = modifiers & B_CONTROL_KEY;
+    m_metaKey = modifiers & B_OPTION_KEY;
 }
 
-void PlatformKeyboardEvent::disambiguateKeyDownEvent(Type type, bool)
+void PlatformKeyboardEvent::disambiguateKeyDownEvent(Type type, bool backwardCompatibilityMode)
 {
     // Can only change type from KeyDown to RawKeyDown or Char, as we lack information for other conversions.
     ASSERT(m_type == KeyDown);
     m_type = type;
+
+    if (backwardCompatibilityMode)
+        return;
+
     if (type == RawKeyDown) {
         m_text = String();
         m_unmodifiedText = String();
@@ -185,8 +374,16 @@ void PlatformKeyboardEvent::disambiguateKeyDownEvent(Type type, bool)
 
 bool PlatformKeyboardEvent::currentCapsLockState()
 {
-    notImplemented();
-    return false;
+    return ::modifiers() & B_CAPS_LOCK;
+}
+
+void PlatformKeyboardEvent::getCurrentModifierState(bool& shiftKey, bool& ctrlKey, bool& altKey, bool& metaKey)
+{
+    unit32 modifiers = ::modifiers();
+    shiftKey = modifiers & B_SHIFT_KEY;
+    ctrlKey = modifiers & B_COMMAND_KEY;
+    altKey = modifiers & B_CONTROL_KEY;
+    metaKey = modifiers & B_OPTION_KEY;
 }
 
 } // namespace WebCore
diff --git a/WebCore/platform/haiku/PlatformMouseEventHaiku.cpp b/WebCore/platform/haiku/PlatformMouseEventHaiku.cpp
index d212f8b..f1051a5 100644
--- a/WebCore/platform/haiku/PlatformMouseEventHaiku.cpp
+++ b/WebCore/platform/haiku/PlatformMouseEventHaiku.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
  * Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * All rights reserved.
  *
@@ -30,36 +31,30 @@
 #include "PlatformMouseEvent.h"
 
 #include <Message.h>
-#include <SupportDefs.h>
-
+#include <View.h>
 
 namespace WebCore {
 
 PlatformMouseEvent::PlatformMouseEvent(const BMessage* message)
-    : m_timestamp(message->FindInt64("when"))
-    , m_position(IntPoint(message->FindPoint("where")))
-    , m_globalPosition(message->FindPoint("globalPosition"))
-    , m_shiftKey(false)
-    , m_ctrlKey(false)
-    , m_altKey(false)
-    , m_metaKey(false)
+    : m_position(message->FindPoint("be:view_where"))
+    , m_globalPosition(message->FindPoint("screen_where"))
     , m_clickCount(message->FindInt32("clicks"))
+    , m_timestamp(message->FindInt64("when") / 1000000.0)
 {
-    int32 buttons = message->FindInt32("buttons");
-    switch (buttons) {
-    case 1:
+    int32 buttons = 0;
+    if (message->what == B_MOUSE_UP)
+        message->FindInt32("previous buttons", &buttons);
+    else
+        message->FindInt32("buttons", &buttons);
+
+    if (buttons & B_PRIMARY_MOUSE_BUTTON)
         m_button = LeftButton;
-        break;
-    case 2:
+    else if (buttons & B_SECONDARY_MOUSE_BUTTON)
         m_button = RightButton;
-        break;
-    case 3:
+    else if (buttons & B_TERTIARY_MOUSE_BUTTON)
         m_button = MiddleButton;
-        break;
-    default:
+    else
         m_button = NoButton;
-        break;
-    };
 
     switch (message->what) {
     case B_MOUSE_DOWN:
@@ -67,15 +62,18 @@ PlatformMouseEvent::PlatformMouseEvent(const BMessage* message)
         break;
     case B_MOUSE_UP:
         m_eventType = MouseEventReleased;
-        m_button = LeftButton; // FIXME: Webcore wants to know the button released but we don't know.
         break;
     case B_MOUSE_MOVED:
-        m_eventType = MouseEventMoved;
-        break;
     default:
         m_eventType = MouseEventMoved;
         break;
     };
+
+    int32 modifiers = message->FindInt32("modifiers");
+    m_shiftKey = modifiers & B_SHIFT_KEY;
+    m_ctrlKey = modifiers & B_CONTROL_KEY;
+    m_altKey = modifiers & B_COMMAND_KEY;
+    m_metaKey = modifiers & B_OPTION_KEY;
 }
 
 } // namespace WebCore
diff --git a/WebCore/platform/haiku/PlatformWheelEventHaiku.cpp b/WebCore/platform/haiku/PlatformWheelEventHaiku.cpp
index 21003b6..351b4ec 100644
--- a/WebCore/platform/haiku/PlatformWheelEventHaiku.cpp
+++ b/WebCore/platform/haiku/PlatformWheelEventHaiku.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
  * Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * All rights reserved.
  *
@@ -31,6 +32,7 @@
 
 #include "Scrollbar.h"
 
+#include <InterfaceDefs.h>
 #include <Message.h>
 #include <Point.h>
 
@@ -38,24 +40,23 @@
 namespace WebCore {
 
 PlatformWheelEvent::PlatformWheelEvent(BMessage* message)
-    : m_granularity(ScrollByPixelWheelEvent)
-    , m_shiftKey(false)
-    , m_ctrlKey(false)
-    , m_altKey(false)
-    , m_metaKey(false)
+    : m_position(message->FindPoint("be:view_where"))
+    , m_globalPosition(message->FindPoint("screen_where"))
+    , m_deltaX(message->FindFloat("be:wheel_delta_x"))
+    , m_deltaY(message->FindFloat("be:wheel_delta_y"))
+    , m_wheelTicksX(m_deltaX)
+    , m_wheelTicksY(m_deltaY)
+    , m_granularity(ScrollByPixelWheelEvent)
     , m_isAccepted(false)
 {
-    m_position = IntPoint(message->FindPoint("position"));
-    m_globalPosition = IntPoint(message->FindPoint("global_position"));
-
-    m_deltaX = message->FindFloat("be:wheel_delta_x");
-    m_deltaY = message->FindFloat("be:wheel_delta_y");
-
-    m_wheelTicksX = m_deltaX;
-    m_wheelTicksY = m_deltaY;
-
     m_deltaX *= -Scrollbar::pixelsPerLineStep();
     m_deltaY *= -Scrollbar::pixelsPerLineStep();
+
+    int32 modifiers = message->FindInt32("modifiers");
+    m_shiftKey = modifiers & B_SHIFT_KEY;
+    m_ctrlKey = modifiers & B_CONTROL_KEY;
+    m_altKey = modifiers & B_COMMAND_KEY;
+    m_metaKey = modifiers & B_OPTION_KEY;
 }
 
 } // namespace WebCore
diff --git a/WebCore/platform/haiku/PopupMenuHaiku.cpp b/WebCore/platform/haiku/PopupMenuHaiku.cpp
index 9d608c8..5adbc66 100644
--- a/WebCore/platform/haiku/PopupMenuHaiku.cpp
+++ b/WebCore/platform/haiku/PopupMenuHaiku.cpp
@@ -1,7 +1,7 @@
 /*
  * This file is part of the popup menu implementation for <select> elements in WebCore.
  *
- * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -26,42 +26,165 @@
 #include "FrameView.h"
 
 #include "NotImplemented.h"
-#include <Menu.h>
-
+#include <Application.h>
+#include <Handler.h>
+#include <MenuItem.h>
+#include <Message.h>
+#include <PopUpMenu.h>
+#include <String.h>
+#include <Window.h>
+#include <support/Autolock.h>
+#include <support/Locker.h>
 
 namespace WebCore {
 
+static const uint32 kPopupResult = 'pmrs';
+static const uint32 kPopupHidden = 'pmhd';
+
+// This BHandler is added to the application (main) thread, so that we
+// invoke methods on the PopupMenuClient within the main thread.
+class PopupMenuHandler : public BHandler {
+public:
+    PopupMenuHandler(PopupMenuClient* popupClient)
+        : m_popupClient(popupClient)
+    {
+    }
+
+    virtual void MessageReceived(BMessage* message)
+    {
+        switch (message->what) {
+        case kPopupResult: {
+            int32 index = 0;
+            message->FindInt32("index", &index);
+            m_popupClient->valueChanged(index);
+            break;
+        }
+        case kPopupHidden:
+            m_popupClient->popupDidHide();
+            break;
+
+        default:
+            BHandler::MessageReceived(message);
+        }
+    }
+
+private:
+    PopupMenuClient* m_popupClient;
+};
+
+class PopupMenuHaiku : public BPopUpMenu {
+public:
+    PopupMenuHaiku(PopupMenuClient* popupClient)
+        : BPopUpMenu("WebCore Popup", true, false)
+        , m_popupClient(popupClient)
+        , m_Handler(popupClient)
+    {
+        if (be_app->Lock()) {
+            be_app->AddHandler(&m_Handler);
+            be_app->Unlock();
+        }
+        SetAsyncAutoDestruct(false);
+    }
+
+    virtual ~PopupMenuHaiku()
+    {
+        if (be_app->Lock()) {
+            be_app->RemoveHandler(&m_Handler);
+            be_app->Unlock();
+        }
+    }
+
+    void show(const IntRect& rect, FrameView* view, int index)
+    {
+        // Clean out the menu first
+        for (int32 i = CountItems() - 1; i >= 0; i--)
+            delete RemoveItem(i);
+
+        // Popuplate the menu from the client
+        int itemCount = m_popupClient->listSize();
+        for (int i = 0; i < itemCount; i++) {
+            if (m_popupClient->itemIsSeparator(i))
+                AddSeparatorItem();
+            else {
+                // NOTE: WebCore distinguishes between "Group" and "Label"
+                // here, but both types of item (radio or check mark) currently
+                // look the same on Haiku.
+                BString label(m_popupClient->itemText(i));
+                BMessage* message = new BMessage(kPopupResult);
+                message->AddInt32("index", i);
+                BMenuItem* item = new BMenuItem(label.String(), message);
+                AddItem(item);
+                item->SetTarget(BMessenger(&m_Handler));
+                item->SetEnabled(m_popupClient->itemIsEnabled(i));
+                item->SetMarked(i == index);
+            }
+        }
+
+        // We need to force a layout now, or the item frames will not be
+        // computed yet, so we cannot move the current item under the mouse.
+        DoLayout();
+
+        // Account for frame of menu field
+        BRect screenRect(view->contentsToScreen(rect));
+        screenRect.OffsetBy(2, 2);
+        // Move currently selected item under the mouse.
+        if (BMenuItem* item = ItemAt(index))
+            screenRect.OffsetBy(0, -item->Frame().top);
+
+        BRect openRect = Bounds().OffsetToSelf(screenRect.LeftTop());
+
+        Go(screenRect.LeftTop(), true, true, openRect, true);
+    }
+
+    void hide()
+    {
+        if (!IsHidden())
+            Hide();
+    }
+
+private:
+    virtual void Hide()
+    {
+        BPopUpMenu::Hide();
+        be_app->PostMessage(kPopupHidden, &m_Handler);
+    }
+
+    PopupMenuClient* m_popupClient;
+    PopupMenuHandler m_Handler;
+};
+
 PopupMenu::PopupMenu(PopupMenuClient* client)
     : m_popupClient(client)
-    , m_menu(0)
+    , m_menu(new PopupMenuHaiku(client))
 {
+    // We don't need additional references to the client, since we completely
+    // control any sub-objects we create that need it as well.
 }
 
 PopupMenu::~PopupMenu()
 {
     delete m_menu;
-    m_menu = 0;
 }
 
 void PopupMenu::show(const IntRect& rect, FrameView* view, int index)
 {
-    notImplemented();
+    // The menu will update itself from the PopupMenuClient before showing.
+    m_menu->show(rect, view, index);
 }
 
 void PopupMenu::hide()
 {
-    notImplemented();
+    m_menu->hide();
 }
 
 void PopupMenu::updateFromElement()
 {
-    notImplemented();
+    client()->setTextFromItem(m_popupClient->selectedIndex());
 }
 
 bool PopupMenu::itemWritingDirectionIsNatural()
 {
-    notImplemented();
-    return true;
+    return false;
 }
 
 } // namespace WebCore
diff --git a/WebCore/platform/haiku/WidgetHaiku.cpp b/WebCore/platform/haiku/WidgetHaiku.cpp
index 6031fca..5ff504f 100644
--- a/WebCore/platform/haiku/WidgetHaiku.cpp
+++ b/WebCore/platform/haiku/WidgetHaiku.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com>
+ * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
  *
  * All rights reserved.
  *
@@ -29,16 +30,38 @@
 #include "Widget.h"
 
 #include "Cursor.h"
-#include "GraphicsContext.h"
 #include "IntRect.h"
 #include "NotImplemented.h"
-#include <Control.h>
 #include <View.h>
 
-
 namespace WebCore {
 
+class AutoPlatformWidgetLocker {
+public:
+    AutoPlatformWidgetLocker(PlatformWidget widget)
+        : m_widget(widget)
+    {
+        if (!m_widget || m_widget->LockLooperWithTimeout(5000) != B_OK)
+            m_widget = 0;
+    }
+
+    ~AutoPlatformWidgetLocker()
+    {
+        if (m_widget)
+            m_widget->UnlockLooper();
+    }
+
+    bool isLocked() const
+    {
+        return m_widget;
+    }
+
+private:
+    PlatformWidget m_widget;
+};
+
 Widget::Widget(PlatformWidget widget)
+    : m_topLevelPlatformWidget(0)
 {
     init(widget);
 }
@@ -59,29 +82,41 @@ void Widget::setFrameRect(const IntRect& rect)
 
 void Widget::setFocus()
 {
-    if (platformWidget())
-        platformWidget()->MakeFocus();
+    AutoPlatformWidgetLocker locker(topLevelPlatformWidget());
+    if (locker.isLocked())
+        topLevelPlatformWidget()->MakeFocus();
 }
 
 void Widget::setCursor(const Cursor& cursor)
 {
-    if (platformWidget())
-        platformWidget()->SetViewCursor(cursor.impl());
+    AutoPlatformWidgetLocker locker(topLevelPlatformWidget());
+    if (locker.isLocked())
+        topLevelPlatformWidget()->SetViewCursor(cursor.impl());
 }
 
 void Widget::show()
 {
-    if (platformWidget())
+    setSelfVisible(true);
+    if (!isParentVisible())
+        return;
+
+    AutoPlatformWidgetLocker locker(platformWidget());
+    if (locker.isLocked() && platformWidget()->IsHidden())
         platformWidget()->Show();
 }
 
 void Widget::hide()
 {
-    if (platformWidget())
+    setSelfVisible(false);
+    if (!isParentVisible())
+        return;
+
+    AutoPlatformWidgetLocker locker(platformWidget());
+    if (locker.isLocked() && !platformWidget()->IsHidden())
         platformWidget()->Hide();
 }
 
-void Widget::paint(GraphicsContext* p, IntRect const& r)
+void Widget::paint(GraphicsContext*, IntRect const&)
 {
     notImplemented();
 }