external/webkit r30707

33 files changed, 7321 insertions, 0 deletions

diff --git a/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp b/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp
new file mode 100644
index 0000000..28cd9b6
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp
@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ * Copyright (C) 2007, 2008 Christian Dywan <christian@imendio.com>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "ChromeClientGtk.h"
+
+#include "FloatRect.h"
+#include "IntRect.h"
+#include "PlatformString.h"
+#include "CString.h"
+#include "HitTestResult.h"
+#include "KURL.h"
+#include "webkitwebview.h"
+#include "webkitprivate.h"
+#include "NotImplemented.h"
+#include "WindowFeatures.h"
+
+using namespace WebCore;
+
+namespace WebKit {
+ChromeClient::ChromeClient(WebKitWebView* webView)
+    : m_webView(webView)
+{
+}
+
+void ChromeClient::chromeDestroyed()
+{
+    delete this;
+}
+
+FloatRect ChromeClient::windowRect()
+{
+    if (!m_webView)
+        return FloatRect();
+    GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
+    if (window) {
+        gint left, top, width, height;
+        gtk_window_get_position(GTK_WINDOW(window), &left, &top);
+        gtk_window_get_size(GTK_WINDOW(window), &width, &height);
+        return IntRect(left, top, width, height);
+    }
+    return FloatRect();
+}
+
+void ChromeClient::setWindowRect(const FloatRect& r)
+{
+    notImplemented();
+}
+
+FloatRect ChromeClient::pageRect()
+{
+    if (!m_webView)
+        return FloatRect();
+    GtkAllocation allocation = GTK_WIDGET(m_webView)->allocation;
+    return IntRect(allocation.x, allocation.y, allocation.width, allocation.height);
+}
+
+float ChromeClient::scaleFactor()
+{
+    // Not implementable
+    return 1.0;
+}
+
+void ChromeClient::focus()
+{
+    if (!m_webView)
+        return;
+    gtk_widget_grab_focus(GTK_WIDGET(m_webView));
+}
+
+void ChromeClient::unfocus()
+{
+    if (!m_webView)
+        return;
+    GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
+    if (window)
+        gtk_window_set_focus(GTK_WINDOW(window), NULL);
+}
+
+Page* ChromeClient::createWindow(Frame*, const FrameLoadRequest&, const WindowFeatures& features)
+{
+    if (features.dialog) {
+        notImplemented();
+        return 0;
+    } else {
+        /* TODO: FrameLoadRequest is not used */
+        WebKitWebView* webView = WEBKIT_WEB_VIEW_GET_CLASS(m_webView)->create_web_view(m_webView);
+        if (!webView)
+            return 0;
+
+        WebKitWebViewPrivate* privateData = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
+        return privateData->corePage;
+    }
+}
+
+void ChromeClient::show()
+{
+    notImplemented();
+}
+
+bool ChromeClient::canRunModal()
+{
+    notImplemented();
+    return false;
+}
+
+void ChromeClient::runModal()
+{
+    notImplemented();
+}
+
+void ChromeClient::setToolbarsVisible(bool)
+{
+    notImplemented();
+}
+
+bool ChromeClient::toolbarsVisible()
+{
+    notImplemented();
+    return false;
+}
+
+void ChromeClient::setStatusbarVisible(bool)
+{
+    notImplemented();
+}
+
+bool ChromeClient::statusbarVisible()
+{
+    notImplemented();
+    return false;
+}
+
+void ChromeClient::setScrollbarsVisible(bool)
+{
+    notImplemented();
+}
+
+bool ChromeClient::scrollbarsVisible() {
+    notImplemented();
+    return false;
+}
+
+void ChromeClient::setMenubarVisible(bool)
+{
+    notImplemented();
+}
+
+bool ChromeClient::menubarVisible()
+{
+    notImplemented();
+    return false;
+}
+
+void ChromeClient::setResizable(bool)
+{
+    notImplemented();
+}
+
+void ChromeClient::closeWindowSoon()
+{
+    notImplemented();
+}
+
+bool ChromeClient::canTakeFocus(FocusDirection)
+{
+    if (!m_webView)
+        return false;
+    return GTK_WIDGET_CAN_FOCUS(m_webView);
+}
+
+void ChromeClient::takeFocus(FocusDirection)
+{
+    unfocus();
+}
+
+bool ChromeClient::canRunBeforeUnloadConfirmPanel()
+{
+    return true;
+}
+
+bool ChromeClient::runBeforeUnloadConfirmPanel(const WebCore::String& message, WebCore::Frame* frame)
+{
+    return runJavaScriptConfirm(frame, message);
+}
+
+void ChromeClient::addMessageToConsole(const WebCore::String& message, unsigned int lineNumber, const WebCore::String& sourceId)
+{
+    gboolean retval;
+    g_signal_emit_by_name(m_webView, "console-message", message.utf8().data(), lineNumber, sourceId.utf8().data(), &retval);
+}
+
+void ChromeClient::runJavaScriptAlert(Frame* frame, const String& message)
+{
+    gboolean retval;
+    g_signal_emit_by_name(m_webView, "script-alert", kit(frame), message.utf8().data(), &retval);
+}
+
+bool ChromeClient::runJavaScriptConfirm(Frame* frame, const String& message)
+{
+    gboolean retval;
+    gboolean didConfirm;
+    g_signal_emit_by_name(m_webView, "script-confirm", kit(frame), message.utf8().data(), &didConfirm, &retval);
+    return didConfirm == TRUE;
+}
+
+bool ChromeClient::runJavaScriptPrompt(Frame* frame, const String& message, const String& defaultValue, String& result)
+{
+    gboolean retval;
+    gchar* value = 0;
+    g_signal_emit_by_name(m_webView, "script-prompt", kit(frame), message.utf8().data(), defaultValue.utf8().data(), &value, &retval);
+    if (value) {
+        result = String::fromUTF8(value);
+        g_free(value);
+        return true;
+    }
+    return false;
+}
+
+void ChromeClient::setStatusbarText(const String& string)
+{
+    CString stringMessage = string.utf8();
+    g_signal_emit_by_name(m_webView, "status-bar-text-changed", stringMessage.data());
+}
+
+bool ChromeClient::shouldInterruptJavaScript()
+{
+    notImplemented();
+    return false;
+}
+
+bool ChromeClient::tabsToLinks() const
+{
+    return true;
+}
+
+IntRect ChromeClient::windowResizerRect() const
+{
+    notImplemented();
+    return IntRect();
+}
+
+void ChromeClient::addToDirtyRegion(const IntRect&)
+{
+    notImplemented();
+}
+
+void ChromeClient::scrollBackingStore(int dx, int dy, const IntRect& scrollViewRect, const IntRect& clipRect)
+{
+    notImplemented();
+}
+
+void ChromeClient::updateBackingStore()
+{
+    notImplemented();
+}
+
+void ChromeClient::mouseDidMoveOverElement(const HitTestResult& hit, unsigned modifierFlags)
+{
+    // check if the element is a link...
+    bool isLink = hit.isLiveLink();
+    if (isLink) {
+        KURL url = hit.absoluteLinkURL();
+        if (!url.isEmpty() && url != m_hoveredLinkURL) {
+            CString titleString = hit.title().utf8();
+            CString urlString = url.prettyURL().utf8();
+            g_signal_emit_by_name(m_webView, "hovering-over-link", titleString.data(), urlString.data());
+            m_hoveredLinkURL = url;
+        }
+    } else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
+        g_signal_emit_by_name(m_webView, "hovering-over-link", 0, 0);
+        m_hoveredLinkURL = KURL();
+    }
+}
+
+void ChromeClient::setToolTip(const String& toolTip)
+{
+#if GTK_CHECK_VERSION(2,12,0)
+    if (toolTip.isEmpty())
+        g_object_set(G_OBJECT(m_webView), "has-tooltip", FALSE, NULL);
+    else
+        gtk_widget_set_tooltip_text(GTK_WIDGET(m_webView), toolTip.utf8().data());
+#else
+    // TODO: Support older GTK+ versions
+    // See http://bugs.webkit.org/show_bug.cgi?id=15793
+    notImplemented();
+#endif
+}
+
+void ChromeClient::print(Frame* frame)
+{
+    webkit_web_frame_print(kit(frame));
+}
+
+void ChromeClient::exceededDatabaseQuota(Frame*, const String&)
+{
+    notImplemented();
+}
+
+}
diff --git a/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h b/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h
new file mode 100644
index 0000000..465dc9f
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef ChromeClientGtk_h
+#define ChromeClientGtk_h
+
+#include "ChromeClient.h"
+#include "KURL.h"
+
+typedef struct _WebKitWebView WebKitWebView;
+
+namespace WebKit {
+
+    class ChromeClient : public WebCore::ChromeClient {
+    public:
+        ChromeClient(WebKitWebView*);
+        WebKitWebView* webView() const { return m_webView; }
+
+        virtual void chromeDestroyed();
+
+        virtual void setWindowRect(const WebCore::FloatRect&);
+        virtual WebCore::FloatRect windowRect();
+
+        virtual WebCore::FloatRect pageRect();
+
+        virtual float scaleFactor();
+
+        virtual void focus();
+        virtual void unfocus();
+
+        virtual bool canTakeFocus(WebCore::FocusDirection);
+        virtual void takeFocus(WebCore::FocusDirection);
+
+        virtual WebCore::Page* createWindow(WebCore::Frame*, const WebCore::FrameLoadRequest&, const WebCore::WindowFeatures&);
+        virtual void show();
+
+        virtual bool canRunModal();
+        virtual void runModal();
+
+        virtual void setToolbarsVisible(bool);
+        virtual bool toolbarsVisible();
+
+        virtual void setStatusbarVisible(bool);
+        virtual bool statusbarVisible();
+
+        virtual void setScrollbarsVisible(bool);
+        virtual bool scrollbarsVisible();
+
+        virtual void setMenubarVisible(bool);
+        virtual bool menubarVisible();
+
+        virtual void setResizable(bool);
+
+        virtual void addMessageToConsole(const WebCore::String& message, unsigned int lineNumber,
+                                         const WebCore::String& sourceID);
+
+        virtual bool canRunBeforeUnloadConfirmPanel();
+        virtual bool runBeforeUnloadConfirmPanel(const WebCore::String& message, WebCore::Frame* frame);
+
+        virtual void closeWindowSoon();
+
+        virtual void runJavaScriptAlert(WebCore::Frame*, const WebCore::String&);
+        virtual bool runJavaScriptConfirm(WebCore::Frame*, const WebCore::String&);
+        virtual bool runJavaScriptPrompt(WebCore::Frame*, const WebCore::String& message, const WebCore::String& defaultValue, WebCore::String& result);
+        virtual void setStatusbarText(const WebCore::String&);
+        virtual bool shouldInterruptJavaScript();
+        virtual bool tabsToLinks() const;
+
+        virtual WebCore::IntRect windowResizerRect() const;
+        virtual void addToDirtyRegion(const WebCore::IntRect&);
+        virtual void scrollBackingStore(int dx, int dy, const WebCore::IntRect& scrollViewRect, const WebCore::IntRect& clipRect);
+        virtual void updateBackingStore();
+
+        virtual void mouseDidMoveOverElement(const WebCore::HitTestResult&, unsigned modifierFlags);
+
+        virtual void setToolTip(const WebCore::String&);
+
+        virtual void print(WebCore::Frame*);
+
+        virtual void exceededDatabaseQuota(WebCore::Frame*, const WebCore::String&);
+
+    private:
+        WebKitWebView* m_webView;
+        WebCore::KURL m_hoveredLinkURL;
+    };
+}
+
+#endif // ChromeClient_h
diff --git a/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.cpp b/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.cpp
new file mode 100644
index 0000000..6a2feb2
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.cpp
@@ -0,0 +1,75 @@
+/*
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "ContextMenu.h"
+#include "ContextMenuClientGtk.h"
+
+#include "HitTestResult.h"
+#include "KURL.h"
+#include "NotImplemented.h"
+
+using namespace WebCore;
+
+namespace WebKit {
+
+void ContextMenuClient::contextMenuDestroyed()
+{
+    delete this;
+}
+
+PlatformMenuDescription ContextMenuClient::getCustomMenuFromDefaultItems(ContextMenu* menu)
+{
+    return menu->releasePlatformDescription();
+}
+
+void ContextMenuClient::contextMenuItemSelected(ContextMenuItem*, const ContextMenu*)
+{
+    notImplemented();
+}
+
+void ContextMenuClient::downloadURL(const KURL& url)
+{
+    notImplemented();
+}
+
+void ContextMenuClient::copyImageToClipboard(const HitTestResult&)
+{
+    notImplemented();
+}
+
+void ContextMenuClient::searchWithGoogle(const Frame*)
+{
+    notImplemented();
+}
+
+void ContextMenuClient::lookUpInDictionary(Frame*)
+{
+    notImplemented();
+}
+
+void ContextMenuClient::speak(const String&)
+{
+    notImplemented();
+}
+
+void ContextMenuClient::stopSpeaking()
+{
+    notImplemented();
+}
+
+}
+
diff --git a/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.h b/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.h
new file mode 100644
index 0000000..c0e8069
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/ContextMenuClientGtk.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2006 Zack Rusin <zack@kde.org>
+ *
+ * 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 ContextMenuClientGtk_h
+#define ContextMenuClientGtk_h
+
+#include "ContextMenuClient.h"
+
+namespace WebCore {
+    class ContextMenu;
+}
+
+namespace WebKit {
+
+    class ContextMenuClient : public WebCore::ContextMenuClient
+    {
+    public:
+        virtual void contextMenuDestroyed();
+
+        virtual WebCore::PlatformMenuDescription getCustomMenuFromDefaultItems(WebCore::ContextMenu*);
+        virtual void contextMenuItemSelected(WebCore::ContextMenuItem*, const WebCore::ContextMenu*);
+
+        virtual void downloadURL(const WebCore::KURL& url);
+        virtual void copyImageToClipboard(const WebCore::HitTestResult&);
+        virtual void searchWithGoogle(const WebCore::Frame*);
+        virtual void lookUpInDictionary(WebCore::Frame*);
+        virtual void speak(const WebCore::String&);
+        virtual void stopSpeaking();
+    };
+}
+
+#endif
diff --git a/WebKit/gtk/WebCoreSupport/DragClientGtk.cpp b/WebKit/gtk/WebCoreSupport/DragClientGtk.cpp
new file mode 100644
index 0000000..f55b6ea
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/DragClientGtk.cpp
@@ -0,0 +1,64 @@
+/*
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "DragClientGtk.h"
+
+#include "NotImplemented.h"
+
+using namespace WebCore;
+
+namespace WebKit {
+
+void DragClient::willPerformDragDestinationAction(DragDestinationAction, DragData*)
+{
+    notImplemented();
+}
+
+void DragClient::willPerformDragSourceAction(DragSourceAction, const IntPoint&, Clipboard*)
+{
+    notImplemented();
+}
+
+DragDestinationAction DragClient::actionMaskForDrag(DragData*)
+{
+    notImplemented();
+    return DragDestinationActionAny;
+}
+
+DragSourceAction DragClient::dragSourceActionMaskForPoint(const IntPoint&)
+{
+    notImplemented();
+    return DragSourceActionAny;
+}
+
+void DragClient::startDrag(DragImageRef, const IntPoint&, const IntPoint&, Clipboard*, Frame*, bool)
+{
+    notImplemented();
+}
+
+DragImageRef DragClient::createDragImageForLink(KURL&, const String& label, Frame*)
+{
+    notImplemented();
+    return 0;
+}
+
+void DragClient::dragControllerDestroyed()
+{
+    delete this;
+}
+}
+
diff --git a/WebKit/gtk/WebCoreSupport/DragClientGtk.h b/WebKit/gtk/WebCoreSupport/DragClientGtk.h
new file mode 100644
index 0000000..4367c68
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/DragClientGtk.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ *
+ * 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.
+ * 3.  Neither the name of Apple, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 DragClientGtk_h
+#define DragClientGtk_h
+
+#include "DragClient.h"
+
+namespace WebKit {
+    class DragClient : public WebCore::DragClient {
+    public:
+        virtual void willPerformDragDestinationAction(WebCore::DragDestinationAction, WebCore::DragData*);
+        virtual void willPerformDragSourceAction(WebCore::DragSourceAction, const WebCore::IntPoint&, WebCore::Clipboard*);
+        virtual WebCore::DragDestinationAction actionMaskForDrag(WebCore::DragData*);
+
+        virtual WebCore::DragSourceAction dragSourceActionMaskForPoint(const WebCore::IntPoint& windowPoint);
+
+        virtual void startDrag(WebCore::DragImageRef dragImage, const WebCore::IntPoint& dragImageOrigin, const WebCore::IntPoint& eventPos, WebCore::Clipboard*, WebCore::Frame*, bool linkDrag = false);
+        virtual WebCore::DragImageRef createDragImageForLink(WebCore::KURL&, const WebCore::String& label, WebCore::Frame*);
+
+        virtual void dragControllerDestroyed();
+    };
+}
+
+#endif
diff --git a/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp b/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp
new file mode 100644
index 0000000..8b6c954
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp
@@ -0,0 +1,451 @@
+/*
+ *  Copyright (C) 2007 Alp Toker <alp@atoker.com>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "EditorClientGtk.h"
+
+#include "EditCommand.h"
+#include "Editor.h"
+#include "FocusController.h"
+#include "Frame.h"
+#include "KeyboardCodes.h"
+#include "KeyboardEvent.h"
+#include "NotImplemented.h"
+#include "Page.h"
+#include "PlatformKeyboardEvent.h"
+#include "webkitprivate.h"
+
+using namespace WebCore;
+
+namespace WebKit {
+
+static void imContextCommitted(GtkIMContext* context, const char* str, EditorClient* client)
+{
+    Frame* frame = core(client->m_webView)->focusController()->focusedOrMainFrame();
+    frame->editor()->insertTextWithoutSendingTextEvent(String::fromUTF8(str), false);
+}
+
+bool EditorClient::shouldDeleteRange(Range*)
+{
+    notImplemented();
+    return true;
+}
+
+bool EditorClient::shouldShowDeleteInterface(HTMLElement*)
+{
+    return false;
+}
+
+bool EditorClient::isContinuousSpellCheckingEnabled()
+{
+    notImplemented();
+    return false;
+}
+
+bool EditorClient::isGrammarCheckingEnabled()
+{
+    notImplemented();
+    return false;
+}
+
+int EditorClient::spellCheckerDocumentTag()
+{
+    notImplemented();
+    return 0;
+}
+
+bool EditorClient::shouldBeginEditing(WebCore::Range*)
+{
+    notImplemented();
+    return true;
+}
+
+bool EditorClient::shouldEndEditing(WebCore::Range*)
+{
+    notImplemented();
+    return true;
+}
+
+bool EditorClient::shouldInsertText(String, Range*, EditorInsertAction)
+{
+    notImplemented();
+    return true;
+}
+
+bool EditorClient::shouldChangeSelectedRange(Range*, Range*, EAffinity, bool)
+{
+    notImplemented();
+    return true;
+}
+
+bool EditorClient::shouldApplyStyle(WebCore::CSSStyleDeclaration*,
+                                      WebCore::Range*)
+{
+    notImplemented();
+    return true;
+}
+
+bool EditorClient::shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*)
+{
+    notImplemented();
+    return true;
+}
+
+void EditorClient::didBeginEditing()
+{
+    notImplemented();
+}
+
+void EditorClient::respondToChangedContents()
+{
+    notImplemented();
+}
+
+void EditorClient::respondToChangedSelection()
+{
+    notImplemented();
+}
+
+void EditorClient::didEndEditing()
+{
+    notImplemented();
+}
+
+void EditorClient::didWriteSelectionToPasteboard()
+{
+    notImplemented();
+}
+
+void EditorClient::didSetSelectionTypesForPasteboard()
+{
+    notImplemented();
+}
+
+bool EditorClient::isEditable()
+{
+    return webkit_web_view_get_editable(m_webView);
+}
+
+void EditorClient::registerCommandForUndo(WTF::PassRefPtr<WebCore::EditCommand>)
+{
+    notImplemented();
+}
+
+void EditorClient::registerCommandForRedo(WTF::PassRefPtr<WebCore::EditCommand>)
+{
+    notImplemented();
+}
+
+void EditorClient::clearUndoRedoOperations()
+{
+    notImplemented();
+}
+
+bool EditorClient::canUndo() const
+{
+    notImplemented();
+    return false;
+}
+
+bool EditorClient::canRedo() const
+{
+    notImplemented();
+    return false;
+}
+
+void EditorClient::undo()
+{
+    notImplemented();
+}
+
+void EditorClient::redo()
+{
+    notImplemented();
+}
+
+bool EditorClient::shouldInsertNode(Node*, Range*, EditorInsertAction)
+{
+    notImplemented();
+    return true;
+}
+
+void EditorClient::pageDestroyed()
+{
+    delete this;
+}
+
+bool EditorClient::smartInsertDeleteEnabled()
+{
+    notImplemented();
+    return false;
+}
+
+void EditorClient::toggleContinuousSpellChecking()
+{
+    notImplemented();
+}
+
+void EditorClient::toggleGrammarChecking()
+{
+}
+
+void EditorClient::handleKeyboardEvent(KeyboardEvent* event)
+{
+    Frame* frame = core(m_webView)->focusController()->focusedOrMainFrame();
+    if (!frame || !frame->document()->focusedNode())
+        return;
+
+    const PlatformKeyboardEvent* kevent = event->keyEvent();
+    if (!kevent || kevent->type() == PlatformKeyboardEvent::KeyUp)
+        return;
+
+    Node* start = frame->selectionController()->start().node();
+    if (!start)
+        return;
+
+    // FIXME: Use GtkBindingSet instead of this hard-coded switch
+    // http://bugs.webkit.org/show_bug.cgi?id=15911
+
+    if (start->isContentEditable()) {
+        switch (kevent->windowsVirtualKeyCode()) {
+            case VK_BACK:
+                frame->editor()->deleteWithDirection(SelectionController::BACKWARD,
+                        kevent->ctrlKey() ? WordGranularity : CharacterGranularity, false, true);
+                break;
+            case VK_DELETE:
+                frame->editor()->deleteWithDirection(SelectionController::FORWARD,
+                        kevent->ctrlKey() ? WordGranularity : CharacterGranularity, false, true);
+                break;
+            case VK_LEFT:
+                frame->selectionController()->modify(kevent->shiftKey() ? SelectionController::EXTEND : SelectionController::MOVE,
+                        SelectionController::LEFT,
+                        kevent->ctrlKey() ? WordGranularity : CharacterGranularity,
+                        true);
+                break;
+            case VK_RIGHT:
+                frame->selectionController()->modify(kevent->shiftKey() ? SelectionController::EXTEND : SelectionController::MOVE,
+                        SelectionController::RIGHT,
+                        kevent->ctrlKey() ? WordGranularity : CharacterGranularity,
+                        true);
+                break;
+            case VK_UP:
+                frame->selectionController()->modify(kevent->shiftKey() ? SelectionController::EXTEND : SelectionController::MOVE,
+                        SelectionController::BACKWARD,
+                        kevent->ctrlKey() ? ParagraphGranularity : LineGranularity,
+                        true);
+                break;
+            case VK_DOWN:
+                frame->selectionController()->modify(kevent->shiftKey() ? SelectionController::EXTEND : SelectionController::MOVE,
+                        SelectionController::FORWARD,
+                        kevent->ctrlKey() ? ParagraphGranularity : LineGranularity,
+                        true);
+                break;
+            case VK_PRIOR:  // PageUp
+                frame->editor()->command("MovePageUp").execute();
+                break;
+            case VK_NEXT:  // PageDown
+                frame->editor()->command("MovePageDown").execute();
+                break;
+            case VK_HOME:
+                if (kevent->ctrlKey() && kevent->shiftKey())
+                    frame->editor()->command("MoveToBeginningOfDocumentAndModifySelection").execute();
+                else if (kevent->ctrlKey())
+                    frame->editor()->command("MoveToBeginningOfDocument").execute();
+                else if (kevent->shiftKey())
+                    frame->editor()->command("MoveToBeginningOfLineAndModifySelection").execute();
+                else
+                    frame->editor()->command("MoveToBeginningOfLine").execute();
+                break;
+            case VK_END:
+                if (kevent->ctrlKey() && kevent->shiftKey())
+                    frame->editor()->command("MoveToEndOfDocumentAndModifySelection").execute();
+                else if (kevent->ctrlKey())
+                    frame->editor()->command("MoveToEndOfDocument").execute();
+                else if (kevent->shiftKey())
+                    frame->editor()->command("MoveToEndOfLineAndModifySelection").execute();
+                else
+                    frame->editor()->command("MoveToEndOfLine").execute();
+                break;
+            case VK_RETURN:
+                frame->editor()->command("InsertLineBreak").execute();
+                break;
+            case VK_TAB:
+                return;
+            default:
+                if (!kevent->ctrlKey() && !kevent->altKey() && !kevent->text().isEmpty()) {
+                    if (kevent->text().length() == 1) {
+                        UChar ch = kevent->text()[0];
+                        // Don't insert null or control characters as they can result in unexpected behaviour
+                        if (ch < ' ')
+                            break;
+                    }
+                    frame->editor()->insertText(kevent->text(), event);
+                } else if (kevent->ctrlKey()) {
+                    switch (kevent->windowsVirtualKeyCode()) {
+                        case VK_B:
+                            frame->editor()->command("ToggleBold").execute();
+                            break;
+                        case VK_I:
+                            frame->editor()->command("ToggleItalic").execute();
+                            break;
+                        case VK_Y:
+                            frame->editor()->command("Redo").execute();
+                            break;
+                        case VK_Z:
+                            frame->editor()->command("Undo").execute();
+                            break;
+                        default:
+                            return;
+                    }
+                } else return;
+        }
+    } else {
+        switch (kevent->windowsVirtualKeyCode()) {
+            case VK_UP:
+                frame->editor()->command("MoveUp").execute();
+                break;
+            case VK_DOWN:
+                frame->editor()->command("MoveDown").execute();
+                break;
+            case VK_PRIOR:  // PageUp
+                frame->editor()->command("MovePageUp").execute();
+                break;
+            case VK_NEXT:  // PageDown
+                frame->editor()->command("MovePageDown").execute();
+                break;
+            case VK_HOME:
+                if (kevent->ctrlKey())
+                    frame->editor()->command("MoveToBeginningOfDocument").execute();
+                break;
+            case VK_END:
+                if (kevent->ctrlKey())
+                    frame->editor()->command("MoveToEndOfDocument").execute();
+                break;
+            default:
+                return;
+        }
+    }
+    event->setDefaultHandled();
+}
+
+
+void EditorClient::handleInputMethodKeydown(KeyboardEvent*)
+{
+    notImplemented();
+}
+
+EditorClient::EditorClient(WebKitWebView* webView)
+    : m_webView(webView)
+{
+    WebKitWebViewPrivate* priv = m_webView->priv;
+    g_signal_connect(priv->imContext, "commit", G_CALLBACK(imContextCommitted), this);
+}
+
+EditorClient::~EditorClient()
+{
+    WebKitWebViewPrivate* priv = m_webView->priv;
+    g_signal_handlers_disconnect_by_func(priv->imContext, (gpointer)imContextCommitted, this);
+}
+
+void EditorClient::textFieldDidBeginEditing(Element*)
+{
+    gtk_im_context_focus_in(WEBKIT_WEB_VIEW_GET_PRIVATE(m_webView)->imContext);
+}
+
+void EditorClient::textFieldDidEndEditing(Element*)
+{
+    WebKitWebViewPrivate* priv = m_webView->priv;
+
+    gtk_im_context_focus_out(priv->imContext);
+#ifdef MAEMO_CHANGES
+    hildon_gtk_im_context_hide(priv->imContext);
+#endif
+}
+
+void EditorClient::textDidChangeInTextField(Element*)
+{
+    notImplemented();
+}
+
+bool EditorClient::doTextFieldCommandFromEvent(Element* element, KeyboardEvent* event)
+{
+    WebKitWebViewPrivate* priv = m_webView->priv;
+    return gtk_im_context_filter_keypress(priv->imContext, event->keyEvent()->gdkEventKey());
+}
+
+void EditorClient::textWillBeDeletedInTextField(Element*)
+{
+    notImplemented();
+}
+
+void EditorClient::textDidChangeInTextArea(Element*)
+{
+    notImplemented();
+}
+
+void EditorClient::ignoreWordInSpellDocument(const String&)
+{
+    notImplemented();
+}
+
+void EditorClient::learnWord(const String&)
+{
+    notImplemented();
+}
+
+void EditorClient::checkSpellingOfString(const UChar*, int, int*, int*)
+{
+    notImplemented();
+}
+
+void EditorClient::checkGrammarOfString(const UChar*, int, Vector<GrammarDetail>&, int*, int*)
+{
+    notImplemented();
+}
+
+void EditorClient::updateSpellingUIWithGrammarString(const String&, const GrammarDetail&)
+{
+    notImplemented();
+}
+
+void EditorClient::updateSpellingUIWithMisspelledWord(const String&)
+{
+    notImplemented();
+}
+
+void EditorClient::showSpellingUI(bool)
+{
+    notImplemented();
+}
+
+bool EditorClient::spellingUIIsShowing()
+{
+    notImplemented();
+    return false;
+}
+
+void EditorClient::getGuessesForWord(const String&, Vector<String>&)
+{
+    notImplemented();
+}
+
+void EditorClient::setInputMethodState(bool)
+{
+}
+
+}
diff --git a/WebKit/gtk/WebCoreSupport/EditorClientGtk.h b/WebKit/gtk/WebCoreSupport/EditorClientGtk.h
new file mode 100644
index 0000000..f2bc194
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/EditorClientGtk.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2006 Nikolas Zimmermann <zimmermann@kde.org>
+ * Copyright (C) 2006 Zack Rusin <zack@kde.org>
+ * Copyright (C) 2006 Apple Computer, Inc.
+ *
+ * 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 EditorClientGtk_h
+#define EditorClientGtk_h
+
+#include "EditorClient.h"
+
+#include <wtf/Forward.h>
+
+typedef struct _WebKitWebView WebKitWebView;
+
+namespace WebCore {
+    class Page;
+}
+
+namespace WebKit {
+
+    class EditorClient : public WebCore::EditorClient {
+    public:
+        EditorClient(WebKitWebView*);
+        ~EditorClient();
+
+        // from EditorClient
+        virtual void pageDestroyed();
+
+        virtual bool shouldDeleteRange(WebCore::Range*);
+        virtual bool shouldShowDeleteInterface(WebCore::HTMLElement*);
+        virtual bool smartInsertDeleteEnabled();
+        virtual bool isContinuousSpellCheckingEnabled();
+        virtual void toggleContinuousSpellChecking();
+        virtual bool isGrammarCheckingEnabled();
+        virtual void toggleGrammarChecking();
+        virtual int spellCheckerDocumentTag();
+
+        virtual bool isEditable();
+
+        virtual bool shouldBeginEditing(WebCore::Range*);
+        virtual bool shouldEndEditing(WebCore::Range*);
+        virtual bool shouldInsertNode(WebCore::Node*, WebCore::Range*, WebCore::EditorInsertAction);
+        virtual bool shouldInsertText(WebCore::String, WebCore::Range*, WebCore::EditorInsertAction);
+        virtual bool shouldChangeSelectedRange(WebCore::Range* fromRange, WebCore::Range* toRange, WebCore::EAffinity, bool stillSelecting);
+
+        virtual bool shouldApplyStyle(WebCore::CSSStyleDeclaration*, WebCore::Range*);
+
+        virtual bool shouldMoveRangeAfterDelete(WebCore::Range*, WebCore::Range*);
+
+        virtual void didBeginEditing();
+        virtual void respondToChangedContents();
+        virtual void respondToChangedSelection();
+        virtual void didEndEditing();
+        virtual void didWriteSelectionToPasteboard();
+        virtual void didSetSelectionTypesForPasteboard();
+
+        virtual void registerCommandForUndo(WTF::PassRefPtr<WebCore::EditCommand>);
+        virtual void registerCommandForRedo(WTF::PassRefPtr<WebCore::EditCommand>);
+        virtual void clearUndoRedoOperations();
+
+        virtual bool canUndo() const;
+        virtual bool canRedo() const;
+
+        virtual void undo();
+        virtual void redo();
+
+        virtual void handleKeyboardEvent(WebCore::KeyboardEvent*);
+        virtual void handleInputMethodKeydown(WebCore::KeyboardEvent*);
+
+        virtual void textFieldDidBeginEditing(WebCore::Element*);
+        virtual void textFieldDidEndEditing(WebCore::Element*);
+        virtual void textDidChangeInTextField(WebCore::Element*);
+        virtual bool doTextFieldCommandFromEvent(WebCore::Element*, WebCore::KeyboardEvent*);
+        virtual void textWillBeDeletedInTextField(WebCore::Element*);
+        virtual void textDidChangeInTextArea(WebCore::Element*);
+
+        virtual void ignoreWordInSpellDocument(const WebCore::String&);
+        virtual void learnWord(const WebCore::String&);
+        virtual void checkSpellingOfString(const UChar*, int length, int* misspellingLocation, int* misspellingLength);
+        virtual void checkGrammarOfString(const UChar*, int length, WTF::Vector<WebCore::GrammarDetail>&, int* badGrammarLocation, int* badGrammarLength);
+        virtual void updateSpellingUIWithGrammarString(const WebCore::String&, const WebCore::GrammarDetail&);
+        virtual void updateSpellingUIWithMisspelledWord(const WebCore::String&);
+        virtual void showSpellingUI(bool show);
+        virtual bool spellingUIIsShowing();
+        virtual void getGuessesForWord(const WebCore::String&, WTF::Vector<WebCore::String>& guesses);
+        virtual void setInputMethodState(bool enabled);
+
+        WebKitWebView* m_webView;
+    };
+}
+
+#endif
+
+// vim: ts=4 sw=4 et
diff --git a/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp b/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp
new file mode 100644
index 0000000..d518f60
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp
@@ -0,0 +1,789 @@
+/*
+ *  Copyright (C) 2007 Alp Toker <alp@atoker.com>
+ *  Copyright (C) 2007, 2008 Holger Hans Peter Freyther
+ *  Copyright (C) 2007 Christian Dywan <christian@twotoasts.de>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "FrameLoaderClientGtk.h"
+
+#include "DocumentLoader.h"
+#include "FrameLoader.h"
+#include "FrameView.h"
+#include "FrameTree.h"
+#include "HTMLFormElement.h"
+#include "HTMLFrameElement.h"
+#include "HTMLFrameOwnerElement.h"
+#include "HTMLNames.h"
+#include "Language.h"
+#include "MIMETypeRegistry.h"
+#include "NotImplemented.h"
+#include "PlatformString.h"
+#include "ResourceRequest.h"
+#include "CString.h"
+#include "ProgressTracker.h"
+#include "kjs_binding.h"
+#include "kjs_proxy.h"
+#include "kjs_window.h"
+#include "webkitwebview.h"
+#include "webkitwebframe.h"
+#include "webkitprivate.h"
+
+#include <JavaScriptCore/APICast.h>
+#include <stdio.h>
+#if PLATFORM(UNIX)
+#include <sys/utsname.h>
+#endif
+
+using namespace WebCore;
+
+namespace WebKit {
+
+FrameLoaderClient::FrameLoaderClient(WebKitWebFrame* frame)
+    : m_frame(frame)
+    , m_userAgent("")
+{
+    ASSERT(m_frame);
+}
+
+static String agentPlatform()
+{
+#ifdef GDK_WINDOWING_X11
+    return "X11";
+#elif defined(GDK_WINDOWING_WIN32)
+    return "Windows";
+#elif defined(GDK_WINDOWING_QUARTZ)
+    return "Macintosh";
+#elif defined(GDK_WINDOWING_DIRECTFB)
+    return "DirectFB";
+#else
+    notImplemented();
+    return "Unknown";
+#endif
+}
+
+static String agentOS()
+{
+#if PLATFORM(DARWIN)
+#if PLATFORM(X86)
+    return "Intel Mac OS X";
+#else
+    return "PPC Mac OS X";
+#endif
+#elif PLATFORM(UNIX)
+    struct utsname name;
+    if (uname(&name) != -1)
+        return String::format("%s %s", name.sysname, name.machine);
+    else
+        return "Unknown";
+#elif PLATFORM(WIN_OS)
+    // FIXME: Compute the Windows version
+    return "Windows";
+#else
+    notImplemented();
+    return "Unknown";
+#endif
+}
+
+static String composeUserAgent()
+{
+    // This is a liberal interpretation of http://www.mozilla.org/build/revised-user-agent-strings.html
+    // See also http://developer.apple.com/internet/safari/faq.html#anchor2
+
+    String ua;
+
+    // Product
+    ua += "Mozilla/5.0";
+
+    // Comment
+    ua += " (";
+    ua += agentPlatform(); // Platform
+    ua += "; U; "; // Security
+    ua += agentOS(); // OS-or-CPU
+    ua += "; ";
+    ua += defaultLanguage(); // Localization information
+    ua += ") ";
+
+    // WebKit Product
+    // FIXME: The WebKit version is hardcoded
+    static const String webKitVersion = "525.1+";
+    ua += "AppleWebKit/" + webKitVersion;
+    ua += " (KHTML, like Gecko, ";
+    // We mention Safari since many broken sites check for it (OmniWeb does this too)
+    // We re-use the WebKit version, though it doesn't seem to matter much in practice
+    ua += "Safari/" + webKitVersion;
+    ua += ") ";
+
+    // Vendor Product
+    ua += g_get_prgname();
+
+    return ua;
+}
+
+String FrameLoaderClient::userAgent(const KURL&)
+{
+    if (m_userAgent.isEmpty())
+        m_userAgent = composeUserAgent();
+
+    return m_userAgent;
+}
+
+WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClient::createDocumentLoader(const WebCore::ResourceRequest& request, const SubstituteData& substituteData)
+{
+    RefPtr<DocumentLoader> loader = new DocumentLoader(request, substituteData);
+    return loader.release();
+}
+
+void FrameLoaderClient::dispatchWillSubmitForm(FramePolicyFunction policyFunction,  PassRefPtr<FormState>)
+{
+    // FIXME: This is surely too simple
+    ASSERT(policyFunction);
+    if (!policyFunction)
+        return;
+    (core(m_frame)->loader()->*policyFunction)(PolicyUse);
+}
+
+
+void FrameLoaderClient::committedLoad(DocumentLoader* loader, const char* data, int length)
+{
+    FrameLoader *fl = loader->frameLoader();
+    fl->setEncoding(m_response.textEncodingName(), false);
+    fl->addData(data, length);
+}
+
+void FrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidCancelAuthenticationChallenge(DocumentLoader*, unsigned long  identifier, const AuthenticationChallenge&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::postProgressStartedNotification()
+{
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+    g_signal_emit_by_name(webView, "load-started", m_frame);
+}
+
+void FrameLoaderClient::postProgressEstimateChangedNotification()
+{
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+    Page* corePage = core(webView);
+
+    g_signal_emit_by_name(webView, "load-progress-changed", lround(corePage->progress()->estimatedProgress()*100));
+}
+
+void FrameLoaderClient::postProgressFinishedNotification()
+{
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+
+    g_signal_emit_by_name(webView, "load-finished", m_frame);
+}
+
+void FrameLoaderClient::frameLoaderDestroyed()
+{
+    m_frame = 0;
+    delete this;
+}
+
+void FrameLoaderClient::dispatchDidReceiveResponse(DocumentLoader*, unsigned long, const ResourceResponse& response)
+{
+    m_response = response;
+}
+
+void FrameLoaderClient::dispatchDecidePolicyForMIMEType(FramePolicyFunction policyFunction, const String&, const ResourceRequest&)
+{
+    // FIXME: we need to call directly here (comment copied from Qt version)
+    ASSERT(policyFunction);
+    if (!policyFunction)
+        return;
+    (core(m_frame)->loader()->*policyFunction)(PolicyUse);
+}
+
+void FrameLoaderClient::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction policyFunction, const NavigationAction&, const ResourceRequest&, const String&)
+{
+    ASSERT(policyFunction);
+    if (!policyFunction)
+        return;
+    // FIXME: I think Qt version marshals this to another thread so when we
+    // have multi-threaded download, we might need to do the same
+    (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
+}
+
+void FrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction policyFunction, const NavigationAction& action, const ResourceRequest& resourceRequest)
+{
+    ASSERT(policyFunction);
+    if (!policyFunction)
+        return;
+
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+    WebKitNetworkRequest* request = webkit_network_request_new(resourceRequest.url().string().utf8().data());
+    WebKitNavigationResponse response;
+
+    g_signal_emit_by_name(webView, "navigation-requested", m_frame, request, &response);
+
+    g_object_unref(request);
+
+    if (response == WEBKIT_NAVIGATION_RESPONSE_IGNORE) {
+        (core(m_frame)->loader()->*policyFunction)(PolicyIgnore);
+        return;
+    }
+
+    (core(m_frame)->loader()->*policyFunction)(PolicyUse);
+}
+
+Widget* FrameLoaderClient::createPlugin(const IntSize&, Element*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool)
+{
+    notImplemented();
+    return 0;
+}
+
+PassRefPtr<Frame> FrameLoaderClient::createFrame(const KURL& url, const String& name, HTMLFrameOwnerElement* ownerElement,
+                                                 const String& referrer, bool allowsScrolling, int marginWidth, int marginHeight)
+{
+    Frame* coreFrame = core(webFrame());
+
+    ASSERT(core(getViewFromFrame(webFrame())) == coreFrame->page());
+    WebKitWebFrame* gtkFrame = WEBKIT_WEB_FRAME(webkit_web_frame_init_with_web_view(getViewFromFrame(webFrame()), ownerElement));
+    RefPtr<Frame> childFrame(adoptRef(core(gtkFrame)));
+
+    coreFrame->tree()->appendChild(childFrame);
+
+    childFrame->tree()->setName(name);
+    childFrame->init();
+    childFrame->loader()->load(url, referrer, FrameLoadTypeRedirectWithLockedHistory, String(), 0, 0);
+
+    // The frame's onload handler may have removed it from the document.
+    if (!childFrame->tree()->parent())
+        return 0;
+
+    // Propagate the marginwidth/height and scrolling modes to the view.
+    if (ownerElement->hasTagName(HTMLNames::frameTag) || ownerElement->hasTagName(HTMLNames::iframeTag)) {
+        HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);
+        if (frameElt->scrollingMode() == ScrollbarAlwaysOff)
+            childFrame->view()->setScrollbarsMode(ScrollbarAlwaysOff);
+        int marginWidth = frameElt->getMarginWidth();
+        int marginHeight = frameElt->getMarginHeight();
+        if (marginWidth != -1)
+            childFrame->view()->setMarginWidth(marginWidth);
+        if (marginHeight != -1)
+            childFrame->view()->setMarginHeight(marginHeight);
+    }
+
+    return childFrame.release();
+}
+
+void FrameLoaderClient::redirectDataToPlugin(Widget* pluginWidget)
+{
+    notImplemented();
+    return;
+}
+
+Widget* FrameLoaderClient::createJavaAppletWidget(const IntSize&, Element*, const KURL& baseURL,
+                                                  const Vector<String>& paramNames, const Vector<String>& paramValues)
+{
+    notImplemented();
+    return 0;
+}
+
+ObjectContentType FrameLoaderClient::objectContentType(const KURL& url, const String& mimeType)
+{
+    String type = mimeType;
+    // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
+    if (type.isEmpty())
+        type = MIMETypeRegistry::getMIMETypeForExtension(url.path().substring(url.path().reverseFind('.') + 1));
+
+    if (type.isEmpty())
+        return WebCore::ObjectContentFrame;
+
+    if (MIMETypeRegistry::isSupportedImageMIMEType(type))
+        return WebCore::ObjectContentImage;
+
+    if (MIMETypeRegistry::isSupportedNonImageMIMEType(type))
+        return WebCore::ObjectContentFrame;
+
+    return WebCore::ObjectContentNone;
+}
+
+String FrameLoaderClient::overrideMediaType() const
+{
+    notImplemented();
+    return String();
+}
+
+void FrameLoaderClient::windowObjectCleared()
+{
+    // Is this obsolete now?
+    g_signal_emit_by_name(m_frame, "cleared");
+
+    Frame* coreFrame = core(webFrame());
+    ASSERT(coreFrame);
+
+    Settings* settings = coreFrame->settings();
+    if (!settings || !settings->isJavaScriptEnabled())
+        return;
+
+    // TODO: Consider using g_signal_has_handler_pending() to avoid the overhead
+    // when there are no handlers.
+    JSGlobalContextRef context = toGlobalRef(coreFrame->scriptProxy()->globalObject()->globalExec());
+    JSObjectRef windowObject = toRef(KJS::Window::retrieve(coreFrame)->getObject());
+    ASSERT(windowObject);
+
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+    g_signal_emit_by_name(webView, "window-object-cleared", m_frame, context, windowObject);
+
+    // TODO: Re-attach debug clients if present.
+    // The Win port has an example of how we might do this.
+}
+
+void FrameLoaderClient::didPerformFirstNavigation() const
+{
+}
+
+void FrameLoaderClient::registerForIconNotification(bool)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::setMainFrameDocumentReady(bool)
+{
+    // this is only interesting once we provide an external API for the DOM
+}
+
+bool FrameLoaderClient::hasWebView() const
+{
+    notImplemented();
+    return true;
+}
+
+bool FrameLoaderClient::hasFrameView() const
+{
+    notImplemented();
+    return true;
+}
+
+void FrameLoaderClient::dispatchDidFinishLoad()
+{
+    g_signal_emit_by_name(m_frame, "load-done", true);
+}
+
+void FrameLoaderClient::frameLoadCompleted()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::saveViewStateToItem(HistoryItem*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::restoreViewState()
+{
+    notImplemented();
+}
+
+bool FrameLoaderClient::shouldGoToHistoryItem(HistoryItem* item) const
+{
+    // FIXME: This is a very simple implementation. More sophisticated
+    // implementation would delegate the decision to a PolicyDelegate.
+    // See mac implementation for example.
+    return item != 0;
+}
+
+void FrameLoaderClient::makeRepresentation(DocumentLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::forceLayout()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::forceLayoutForNonHTML()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::setCopiesOnScroll()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::detachedFromParent1()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::detachedFromParent2()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::detachedFromParent3()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::detachedFromParent4()
+{
+    ASSERT(m_frame);
+    g_object_unref(m_frame);
+    m_frame = 0;
+}
+
+void FrameLoaderClient::loadedFromCachedPage()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidHandleOnloadEvents()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidCancelClientRedirect()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchWillPerformClientRedirect(const KURL&, double, double)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidChangeLocationWithinPage()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchWillClose()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidReceiveIcon()
+{
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+
+    g_signal_emit_by_name(webView, "icon-loaded", m_frame);
+}
+
+void FrameLoaderClient::dispatchDidStartProvisionalLoad()
+{
+}
+
+void FrameLoaderClient::dispatchDidReceiveTitle(const String& title)
+{
+    g_signal_emit_by_name(m_frame, "title-changed", title.utf8().data());
+
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+    if (m_frame == webkit_web_view_get_main_frame(webView))
+        g_signal_emit_by_name(webView, "title-changed", m_frame, title.utf8().data());
+}
+
+void FrameLoaderClient::dispatchDidCommitLoad()
+{
+    /* Update the URI once first data has been received.
+     * This means the URI is valid and successfully identify the page that's going to be loaded.
+     */
+    WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(m_frame);
+    g_free(frameData->uri);
+    frameData->uri = g_strdup(core(m_frame)->loader()->url().prettyURL().utf8().data());
+
+    g_signal_emit_by_name(m_frame, "load-committed");
+
+    WebKitWebView* webView = getViewFromFrame(m_frame);
+    if (m_frame == webkit_web_view_get_main_frame(webView))
+        g_signal_emit_by_name(webView, "load-committed", m_frame);
+}
+
+void FrameLoaderClient::dispatchDidFinishDocumentLoad()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidFirstLayout()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchShow()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::cancelPolicyCheck()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidLoadMainResource(DocumentLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::revertToProvisionalState(DocumentLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::clearUnarchivingState(DocumentLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::willChangeTitle(DocumentLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::didChangeTitle(DocumentLoader *l)
+{
+    setTitle(l->title(), l->url());
+}
+
+void FrameLoaderClient::finalSetupForReplace(DocumentLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::setDefersLoading(bool)
+{
+    notImplemented();
+}
+
+bool FrameLoaderClient::isArchiveLoadPending(ResourceLoader*) const
+{
+    notImplemented();
+    return false;
+}
+
+void FrameLoaderClient::cancelPendingArchiveLoad(ResourceLoader*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::clearArchivedResources()
+{
+    notImplemented();
+}
+
+bool FrameLoaderClient::canHandleRequest(const ResourceRequest&) const
+{
+    notImplemented();
+    return true;
+}
+
+bool FrameLoaderClient::canShowMIMEType(const String&) const
+{
+    notImplemented();
+    return true;
+}
+
+bool FrameLoaderClient::representationExistsForURLScheme(const String&) const
+{
+    notImplemented();
+    return false;
+}
+
+String FrameLoaderClient::generatedMIMETypeForURLScheme(const String&) const
+{
+    notImplemented();
+    return String();
+}
+
+void FrameLoaderClient::finishedLoading(DocumentLoader* documentLoader)
+{
+    ASSERT(documentLoader->frame());
+    // Setting the encoding on the frame loader is our way to get work done that is normally done
+    // when the first bit of data is received, even for the case of a document with no data (like about:blank).
+    String encoding = documentLoader->overrideEncoding();
+    bool userChosen = !encoding.isNull();
+    if (encoding.isNull())
+        encoding = documentLoader->response().textEncodingName();
+    documentLoader->frameLoader()->setEncoding(encoding, userChosen);
+}
+
+
+void FrameLoaderClient::provisionalLoadStarted()
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::didFinishLoad() {
+    notImplemented();
+}
+
+void FrameLoaderClient::prepareForDataSourceReplacement() { notImplemented(); }
+
+void FrameLoaderClient::setTitle(const String& title, const KURL& url)
+{
+    WebKitWebFramePrivate* frameData = WEBKIT_WEB_FRAME_GET_PRIVATE(m_frame);
+    g_free(frameData->title);
+    frameData->title = g_strdup(title.utf8().data());
+}
+
+void FrameLoaderClient::dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int lengthReceived)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::dispatchDidFailLoading(DocumentLoader*, unsigned long identifier, const ResourceError&)
+{
+    notImplemented();
+}
+
+bool FrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*, const ResourceRequest&, const ResourceResponse&, int length)
+{
+    notImplemented();
+    return false;
+}
+
+void FrameLoaderClient::dispatchDidFailProvisionalLoad(const ResourceError&)
+{
+    g_signal_emit_by_name(m_frame, "load-done", false);
+}
+
+void FrameLoaderClient::dispatchDidFailLoad(const ResourceError&)
+{
+    g_signal_emit_by_name(m_frame, "load-done", false);
+}
+
+void FrameLoaderClient::download(ResourceHandle*, const ResourceRequest&, const ResourceRequest&, const ResourceResponse&)
+{
+    notImplemented();
+}
+
+ResourceError FrameLoaderClient::cancelledError(const ResourceRequest&)
+{
+    notImplemented();
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClient::blockedError(const ResourceRequest&)
+{
+    notImplemented();
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClient::cannotShowURLError(const ResourceRequest&)
+{
+    notImplemented();
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClient::interruptForPolicyChangeError(const ResourceRequest&)
+{
+    notImplemented();
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse&)
+{
+    notImplemented();
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClient::fileDoesNotExistError(const ResourceResponse&)
+{
+    notImplemented();
+    return ResourceError();
+}
+
+bool FrameLoaderClient::shouldFallBack(const ResourceError&)
+{
+    notImplemented();
+    return false;
+}
+
+bool FrameLoaderClient::willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL& originalURL) const
+{
+    notImplemented();
+    return false;
+}
+
+bool FrameLoaderClient::canCachePage() const
+{
+    notImplemented();
+    return false;
+}
+
+Frame* FrameLoaderClient::dispatchCreatePage()
+{
+    notImplemented();
+    return 0;
+}
+
+void FrameLoaderClient::dispatchUnableToImplementPolicy(const ResourceError&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::setMainDocumentError(DocumentLoader*, const ResourceError&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::startDownload(const ResourceRequest&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::updateGlobalHistory(const KURL&)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::savePlatformDataToCachedPage(CachedPage*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::transitionToCommittedFromCachedPage(CachedPage*)
+{
+    notImplemented();
+}
+
+void FrameLoaderClient::transitionToCommittedForNewPage()
+{
+    notImplemented();
+}
+
+}
diff --git a/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.h b/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.h
new file mode 100644
index 0000000..7e5e8b8
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.h
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2006 Zack Rusin <zack@kde.org>
+ * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
+ *
+ * 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 FrameLoaderClientGtk_h
+#define FrameLoaderClientGtk_h
+
+#include "FrameLoaderClient.h"
+#include "ResourceResponse.h"
+
+typedef struct _WebKitWebFrame WebKitWebFrame;
+
+namespace WebKit {
+
+    class FrameLoaderClient : public WebCore::FrameLoaderClient {
+    public:
+        FrameLoaderClient(WebKitWebFrame*);
+        virtual ~FrameLoaderClient() { }
+        virtual void frameLoaderDestroyed();
+
+        WebKitWebFrame*  webFrame() const { return m_frame; }
+
+        virtual bool hasWebView() const;
+        virtual bool hasFrameView() const;
+
+        virtual void makeRepresentation(WebCore::DocumentLoader*);
+        virtual void forceLayout();
+        virtual void forceLayoutForNonHTML();
+
+        virtual void setCopiesOnScroll();
+
+        virtual void detachedFromParent1();
+        virtual void detachedFromParent2();
+        virtual void detachedFromParent3();
+        virtual void detachedFromParent4();
+
+        virtual void loadedFromCachedPage();
+
+        virtual void assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const WebCore::ResourceRequest&);
+
+        virtual void dispatchWillSendRequest(WebCore::DocumentLoader*, unsigned long  identifier, WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse);
+        virtual void dispatchDidReceiveAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long identifier, const WebCore::AuthenticationChallenge&);
+        virtual void dispatchDidCancelAuthenticationChallenge(WebCore::DocumentLoader*, unsigned long  identifier, const WebCore::AuthenticationChallenge&);
+        virtual void dispatchDidReceiveResponse(WebCore::DocumentLoader*, unsigned long  identifier, const WebCore::ResourceResponse&);
+        virtual void dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long identifier, int lengthReceived);
+        virtual void dispatchDidFinishLoading(WebCore::DocumentLoader*, unsigned long  identifier);
+        virtual void dispatchDidFailLoading(WebCore::DocumentLoader*, unsigned long  identifier, const WebCore::ResourceError&);
+        virtual bool dispatchDidLoadResourceFromMemoryCache(WebCore::DocumentLoader*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, int length);
+
+        virtual void dispatchDidHandleOnloadEvents();
+        virtual void dispatchDidReceiveServerRedirectForProvisionalLoad();
+        virtual void dispatchDidCancelClientRedirect();
+        virtual void dispatchWillPerformClientRedirect(const WebCore::KURL&, double, double);
+        virtual void dispatchDidChangeLocationWithinPage();
+        virtual void dispatchWillClose();
+        virtual void dispatchDidReceiveIcon();
+        virtual void dispatchDidStartProvisionalLoad();
+        virtual void dispatchDidReceiveTitle(const WebCore::String&);
+        virtual void dispatchDidCommitLoad();
+        virtual void dispatchDidFailProvisionalLoad(const WebCore::ResourceError&);
+        virtual void dispatchDidFailLoad(const WebCore::ResourceError&);
+        virtual void dispatchDidFinishDocumentLoad();
+        virtual void dispatchDidFinishLoad();
+        virtual void dispatchDidFirstLayout();
+
+        virtual WebCore::Frame* dispatchCreatePage();
+        virtual void dispatchShow();
+
+        virtual void dispatchDecidePolicyForMIMEType(WebCore::FramePolicyFunction, const WebCore::String& MIMEType, const WebCore::ResourceRequest&);
+        virtual void dispatchDecidePolicyForNewWindowAction(WebCore::FramePolicyFunction, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String& frameName);
+        virtual void dispatchDecidePolicyForNavigationAction(WebCore::FramePolicyFunction, const WebCore::NavigationAction&, const WebCore::ResourceRequest&);
+        virtual void cancelPolicyCheck();
+
+        virtual void dispatchUnableToImplementPolicy(const WebCore::ResourceError&);
+
+        virtual void dispatchWillSubmitForm(WebCore::FramePolicyFunction, WTF::PassRefPtr<WebCore::FormState>);
+
+        virtual void dispatchDidLoadMainResource(WebCore::DocumentLoader*);
+        virtual void revertToProvisionalState(WebCore::DocumentLoader*);
+        virtual void setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&);
+        virtual void clearUnarchivingState(WebCore::DocumentLoader*);
+
+        virtual void postProgressStartedNotification();
+        virtual void postProgressEstimateChangedNotification();
+        virtual void postProgressFinishedNotification();
+
+        virtual PassRefPtr<WebCore::Frame> createFrame(const WebCore::KURL& url, const WebCore::String& name, WebCore::HTMLFrameOwnerElement* ownerElement,
+                                   const WebCore::String& referrer, bool allowsScrolling, int marginWidth, int marginHeight);
+        virtual WebCore::Widget* createPlugin(const WebCore::IntSize&, WebCore::Element*, const WebCore::KURL&, const WTF::Vector<WebCore::String>&, const WTF::Vector<WebCore::String>&, const WebCore::String&, bool);
+        virtual void redirectDataToPlugin(WebCore::Widget* pluginWidget);
+        virtual WebCore::Widget* createJavaAppletWidget(const WebCore::IntSize&, WebCore::Element*, const WebCore::KURL& baseURL, const WTF::Vector<WebCore::String>& paramNames, const WTF::Vector<WebCore::String>& paramValues);
+        virtual WebCore::String overrideMediaType() const;
+        virtual void windowObjectCleared();
+        virtual void didPerformFirstNavigation() const;
+
+        virtual void registerForIconNotification(bool);
+
+        virtual WebCore::ObjectContentType objectContentType(const WebCore::KURL& url, const WebCore::String& mimeType);
+
+        virtual void setMainFrameDocumentReady(bool);
+
+        virtual void startDownload(const WebCore::ResourceRequest&);
+
+        virtual void willChangeTitle(WebCore::DocumentLoader*);
+        virtual void didChangeTitle(WebCore::DocumentLoader*);
+
+        virtual void committedLoad(WebCore::DocumentLoader*, const char*, int);
+        virtual void finishedLoading(WebCore::DocumentLoader*);
+        virtual void finalSetupForReplace(WebCore::DocumentLoader*);
+
+        virtual void updateGlobalHistory(const WebCore::KURL&);
+        virtual bool shouldGoToHistoryItem(WebCore::HistoryItem*) const;
+
+        virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&);
+        virtual WebCore::ResourceError blockedError(const WebCore::ResourceRequest&);
+        virtual WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&);
+        virtual WebCore::ResourceError interruptForPolicyChangeError(const WebCore::ResourceRequest&);
+
+        virtual WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&);
+        virtual WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&);
+
+        virtual bool shouldFallBack(const WebCore::ResourceError&);
+
+        virtual void setDefersLoading(bool);
+
+        virtual bool willUseArchive(WebCore::ResourceLoader*, const WebCore::ResourceRequest&, const WebCore::KURL& originalURL) const;
+        virtual bool isArchiveLoadPending(WebCore::ResourceLoader*) const;
+        virtual void cancelPendingArchiveLoad(WebCore::ResourceLoader*);
+        virtual void clearArchivedResources();
+
+        virtual bool canHandleRequest(const WebCore::ResourceRequest&) const;
+        virtual bool canShowMIMEType(const WebCore::String&) const;
+        virtual bool representationExistsForURLScheme(const WebCore::String&) const;
+        virtual WebCore::String generatedMIMETypeForURLScheme(const WebCore::String&) const;
+
+        virtual void frameLoadCompleted();
+        virtual void saveViewStateToItem(WebCore::HistoryItem*);
+        virtual void restoreViewState();
+        virtual void provisionalLoadStarted();
+        virtual void didFinishLoad();
+        virtual void prepareForDataSourceReplacement();
+
+        virtual WTF::PassRefPtr<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&);
+        virtual void setTitle(const WebCore::String& title, const WebCore::KURL&);
+
+        virtual WebCore::String userAgent(const WebCore::KURL&);
+
+        virtual void savePlatformDataToCachedPage(WebCore::CachedPage*);
+        virtual void transitionToCommittedFromCachedPage(WebCore::CachedPage*);
+        virtual void transitionToCommittedForNewPage();
+
+        virtual bool canCachePage() const;
+        virtual void download(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);
+    private:
+        WebKitWebFrame* m_frame;
+        WebCore::ResourceResponse m_response;
+        WebCore::String m_userAgent;
+    };
+
+}
+
+#endif
diff --git a/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp b/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp
new file mode 100644
index 0000000..a54b6a0
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/InspectorClientGtk.cpp
@@ -0,0 +1,80 @@
+/*
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+#include "InspectorClientGtk.h"
+
+#include "NotImplemented.h"
+#include "PlatformString.h"
+
+using namespace WebCore;
+
+namespace WebKit {
+
+void InspectorClient::inspectorDestroyed()
+{
+    delete this;
+}
+
+Page* InspectorClient::createPage()
+{
+    notImplemented();
+    return 0;
+}
+
+String InspectorClient::localizedStringsURL()
+{
+    notImplemented();
+    return String();
+}
+
+void InspectorClient::showWindow()
+{
+    notImplemented();
+}
+
+void InspectorClient::closeWindow()
+{
+    notImplemented();
+}
+
+void InspectorClient::attachWindow()
+{
+    notImplemented();
+}
+
+void InspectorClient::detachWindow()
+{
+    notImplemented();
+}
+
+void InspectorClient::highlight(Node* node)
+{
+    notImplemented();
+}
+
+void InspectorClient::hideHighlight()
+{
+    notImplemented();
+}
+
+void InspectorClient::inspectedURLChanged(const String&)
+{
+    notImplemented();
+}
+
+}
+
diff --git a/WebKit/gtk/WebCoreSupport/InspectorClientGtk.h b/WebKit/gtk/WebCoreSupport/InspectorClientGtk.h
new file mode 100644
index 0000000..9afd42b
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/InspectorClientGtk.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2007 Apple Inc.  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.
+ * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ *     its contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 InspectorClientGtk_h
+#define InspectorClientGtk_h
+
+#include "InspectorClient.h"
+
+namespace WebCore {
+    class Node;
+    class Page;
+    class String;
+}
+
+namespace WebKit {
+
+    class InspectorClient : public WebCore::InspectorClient {
+    public:
+        virtual void inspectorDestroyed();
+
+        virtual WebCore::Page* createPage();
+
+        virtual WebCore::String localizedStringsURL();
+
+        virtual void showWindow();
+        virtual void closeWindow();
+
+        virtual void attachWindow();
+        virtual void detachWindow();
+
+        virtual void highlight(WebCore::Node*);
+        virtual void hideHighlight();
+        virtual void inspectedURLChanged(const WebCore::String& newURL);
+    };
+}
+
+#endif
diff --git a/WebKit/gtk/WebCoreSupport/PasteboardHelperGtk.cpp b/WebKit/gtk/WebCoreSupport/PasteboardHelperGtk.cpp
new file mode 100644
index 0000000..9ef366d
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/PasteboardHelperGtk.cpp
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (C) 2007 Luca Bruno <lethalman88@gmail.com>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "Frame.h"
+#include "PasteboardHelperGtk.h"
+
+#include "webkitwebframe.h"
+#include "webkitwebview.h"
+#include "webkitprivate.h"
+
+#include <gtk/gtk.h>
+
+using namespace WebCore;
+
+namespace WebKit
+{
+
+GtkClipboard* PasteboardHelperGtk::getClipboard(Frame* frame) const {
+    WebKitWebView* webView = webkit_web_frame_get_web_view(kit(frame));
+    return gtk_widget_get_clipboard(GTK_WIDGET (webView),
+                                    GDK_SELECTION_CLIPBOARD);
+}
+
+GtkTargetList* PasteboardHelperGtk::getCopyTargetList(Frame* frame) const {
+    WebKitWebView* webView = webkit_web_frame_get_web_view(kit(frame));
+    return webkit_web_view_get_copy_target_list(webView);
+}
+
+GtkTargetList* PasteboardHelperGtk::getPasteTargetList(Frame* frame) const {
+    WebKitWebView* webView = webkit_web_frame_get_web_view(kit(frame));
+    return webkit_web_view_get_paste_target_list(webView);
+}
+
+}
diff --git a/WebKit/gtk/WebCoreSupport/PasteboardHelperGtk.h b/WebKit/gtk/WebCoreSupport/PasteboardHelperGtk.h
new file mode 100644
index 0000000..77e0457
--- /dev/null
+++ b/WebKit/gtk/WebCoreSupport/PasteboardHelperGtk.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2007 Luca Bruno <lethalman88@gmail.com>
+ * All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef PasteboardHelperGtk_h
+#define PasteboardHelperGtk_h
+
+/*
+ * FIXME: this is for WebCore support and must be removed once
+ * a better solution is found
+ */
+
+#include "Frame.h"
+#include "PasteboardHelper.h"
+
+#include <gtk/gtk.h>
+
+using namespace WebCore;
+
+namespace WebKit {
+
+class PasteboardHelperGtk : public PasteboardHelper {
+public:
+    PasteboardHelperGtk() { }
+    virtual GtkClipboard* getClipboard(Frame*) const;
+    virtual GtkTargetList* getCopyTargetList(Frame*) const;
+    virtual GtkTargetList* getPasteTargetList(Frame*) const;
+};
+
+}
+
+#endif // PasteboardHelperGtk_h
diff --git a/WebKit/gtk/webkit.pc.in b/WebKit/gtk/webkit.pc.in
new file mode 100644
index 0000000..0ce6f71
--- /dev/null
+++ b/WebKit/gtk/webkit.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: WebKit
+Description: Web content engine for GTK+
+Version: @VERSION@
+Requires: gtk+-2.0
+Libs: -L${libdir} -lwebkit-1.0
+Cflags: -I${includedir}/webkit-1.0
diff --git a/WebKit/gtk/webkit/headers.pri b/WebKit/gtk/webkit/headers.pri
new file mode 100644
index 0000000..d53d825
--- /dev/null
+++ b/WebKit/gtk/webkit/headers.pri
@@ -0,0 +1,8 @@
+WEBKIT_API_HEADERS = $$PWD/webkit.h \
+                     $$PWD/webkitdefines.h \
+                     $$PWD/webkitnetworkrequest.h \
+                     $$PWD/webkitwebbackforwardlist.h \
+                     $$PWD/webkitwebframe.h \
+                     $$PWD/webkitwebhistoryitem.h \
+                     $$PWD/webkitwebsettings.h \
+                     $$PWD/webkitwebview.h
diff --git a/WebKit/gtk/webkit/webkit-marshal.list b/WebKit/gtk/webkit/webkit-marshal.list
new file mode 100644
index 0000000..a8f2453
--- /dev/null
+++ b/WebKit/gtk/webkit/webkit-marshal.list
@@ -0,0 +1,12 @@
+VOID:OBJECT
+VOID:STRING
+VOID:STRING,STRING
+VOID:OBJECT,BOOLEAN
+VOID:OBJECT,STRING
+VOID:OBJECT,OBJECT
+VOID:OBJECT,POINTER,POINTER
+BOOLEAN:STRING,INT,STRING
+BOOLEAN:OBJECT,STRING
+BOOLEAN:OBJECT,STRING,BOOLEAN
+BOOLEAN:OBJECT,STRING,STRING,STRING
+INT:OBJECT,OBJECT
diff --git a/WebKit/gtk/webkit/webkit.h b/WebKit/gtk/webkit/webkit.h
new file mode 100644
index 0000000..babd50a
--- /dev/null
+++ b/WebKit/gtk/webkit/webkit.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2007 Alp Toker <alp@atoker.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __WEBKIT_H__
+#define __WEBKIT_H__
+
+#include <webkit/webkitdefines.h>
+#include <webkit/webkitnetworkrequest.h>
+#include <webkit/webkitwebframe.h>
+#include <webkit/webkitwebsettings.h>
+#include <webkit/webkitwebview.h>
+#include <webkit/webkitwebbackforwardlist.h>
+#include <webkit/webkitwebhistoryitem.h>
+
+#endif /* __WEBKIT_H__ */
diff --git a/WebKit/gtk/webkit/webkitdefines.h b/WebKit/gtk/webkit/webkitdefines.h
new file mode 100644
index 0000000..386c3e1
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitdefines.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_DEFINES_H
+#define WEBKIT_DEFINES_H
+
+#include <glib.h>
+
+#ifdef G_OS_WIN32
+    #ifdef BUILDING_WEBKIT
+        #define WEBKIT_API __declspec(dllexport)
+    #else
+        #define WEBKIT_API __declspec(dllimport)
+    #endif
+    #define WEBKIT_OBSOLETE_API WEBKIT_API
+#else
+    #define WEBKIT_API __attribute__((visibility("default")))
+    #define WEBKIT_OBSOLETE_API WEBKIT_API __attribute__((deprecated))
+#endif
+
+#ifndef WEBKIT_API
+    #define WEBKIT_API
+#endif
+
+G_BEGIN_DECLS
+
+typedef struct _WebKitNetworkRequest WebKitNetworkRequest;
+typedef struct _WebKitNetworkRequestClass WebKitNetworkRequestClass;
+
+typedef struct _WebKitWebBackForwardList WebKitWebBackForwardList;
+typedef struct _WebKitWebBackForwardListClass WebKitWebBackForwardListClass;
+
+typedef struct _WebKitWebHistoryItem WebKitWebHistoryItem;
+typedef struct _WebKitWebHistoryItemClass WebKitWebHistoryItemClass;
+
+typedef struct _WebKitWebFrame WebKitWebFrame;
+typedef struct _WebKitWebFrameClass WebKitWebFrameClass;
+
+typedef struct _WebKitWebSettings WebKitWebSettings;
+typedef struct _WebKitWebSettingsClass WebKitWebSettingsClass;
+
+typedef struct _WebKitWebView WebKitWebView;
+typedef struct _WebKitWebViewClass WebKitWebViewClass;
+
+G_END_DECLS
+
+#endif
diff --git a/WebKit/gtk/webkit/webkitnetworkrequest.cpp b/WebKit/gtk/webkit/webkitnetworkrequest.cpp
new file mode 100644
index 0000000..b8711db
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitnetworkrequest.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include "webkitnetworkrequest.h"
+
+extern "C" {
+
+G_DEFINE_TYPE(WebKitNetworkRequest, webkit_network_request, G_TYPE_OBJECT);
+
+struct _WebKitNetworkRequestPrivate {
+    gchar* uri;
+};
+
+#define WEBKIT_NETWORK_REQUEST_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_NETWORK_REQUEST, WebKitNetworkRequestPrivate))
+
+static void webkit_network_request_finalize(GObject* object)
+{
+    WebKitNetworkRequest* request = WEBKIT_NETWORK_REQUEST(object);
+    WebKitNetworkRequestPrivate* priv = request->priv;
+
+    g_free(priv->uri);
+
+    G_OBJECT_CLASS(webkit_network_request_parent_class)->finalize(object);
+}
+
+static void webkit_network_request_class_init(WebKitNetworkRequestClass* requestClass)
+{
+    G_OBJECT_CLASS(requestClass)->finalize = webkit_network_request_finalize;
+
+    g_type_class_add_private(requestClass, sizeof(WebKitNetworkRequestPrivate));
+}
+
+static void webkit_network_request_init(WebKitNetworkRequest* request)
+{
+    WebKitNetworkRequestPrivate* priv = WEBKIT_NETWORK_REQUEST_GET_PRIVATE(request);
+    request->priv = priv;
+}
+
+WebKitNetworkRequest* webkit_network_request_new(const gchar* uri)
+{
+    g_return_val_if_fail(uri, NULL);
+
+    WebKitNetworkRequest* request = WEBKIT_NETWORK_REQUEST(g_object_new(WEBKIT_TYPE_NETWORK_REQUEST, NULL));
+    WebKitNetworkRequestPrivate* priv = request->priv;
+
+    priv->uri = g_strdup(uri);
+
+    return request;
+}
+
+void webkit_network_request_set_uri(WebKitNetworkRequest* request, const gchar* uri)
+{
+    g_return_if_fail(WEBKIT_IS_NETWORK_REQUEST(request));
+    g_return_if_fail(uri);
+
+    WebKitNetworkRequestPrivate* priv = request->priv;
+
+    g_free(priv->uri);
+    priv->uri = g_strdup(uri);
+}
+
+const gchar* webkit_network_request_get_uri(WebKitNetworkRequest* request)
+{
+    g_return_val_if_fail(WEBKIT_IS_NETWORK_REQUEST(request), NULL);
+
+    WebKitNetworkRequestPrivate* priv = request->priv;
+    return priv->uri;
+}
+
+}
diff --git a/WebKit/gtk/webkit/webkitnetworkrequest.h b/WebKit/gtk/webkit/webkitnetworkrequest.h
new file mode 100644
index 0000000..645144a
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitnetworkrequest.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_NETWORK_REQUEST_H
+#define WEBKIT_NETWORK_REQUEST_H
+
+#include <glib-object.h>
+
+#include <webkit/webkitdefines.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_NETWORK_REQUEST            (webkit_network_request_get_type())
+#define WEBKIT_NETWORK_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_NETWORK_REQUEST, WebKitNetworkRequest))
+#define WEBKIT_NETWORK_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_NETWORK_REQUEST, WebKitNetworkRequestClass))
+#define WEBKIT_IS_NETWORK_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_NETWORK_REQUEST))
+#define WEBKIT_IS_NETWORK_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_NETWORK_REQUEST))
+#define WEBKIT_NETWORK_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_NETWORK_REQUEST, WebKitNetworkRequestClass))
+
+typedef struct _WebKitNetworkRequestPrivate WebKitNetworkRequestPrivate;
+
+struct _WebKitNetworkRequest {
+    GObject parent_instance;
+
+    WebKitNetworkRequestPrivate* priv;
+};
+
+struct _WebKitNetworkRequestClass {
+    GObjectClass parent_class;
+};
+
+WEBKIT_API GType
+webkit_network_request_get_type (void);
+
+WEBKIT_API WebKitNetworkRequest*
+webkit_network_request_new (const gchar* uri);
+
+WEBKIT_API void
+webkit_network_request_set_uri (WebKitNetworkRequest* request, const gchar* uri);
+
+WEBKIT_API const gchar*
+webkit_network_request_get_uri (WebKitNetworkRequest* request);
+
+G_END_DECLS
+
+#endif
diff --git a/WebKit/gtk/webkit/webkitprivate.cpp b/WebKit/gtk/webkit/webkitprivate.cpp
new file mode 100644
index 0000000..9ec51ba
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitprivate.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include "webkitprivate.h"
+#include "ChromeClientGtk.h"
+#include "FrameLoader.h"
+#include "FrameLoaderClientGtk.h"
+#include "Logging.h"
+#include "MainThread.h"
+#include "NotImplemented.h"
+#include "Pasteboard.h"
+#include "PasteboardHelperGtk.h"
+
+#if ENABLE(DATABASE)
+#include "DatabaseTracker.h"
+#endif
+
+using namespace WebCore;
+
+namespace WebKit {
+
+WebKitWebView* getViewFromFrame(WebKitWebFrame* frame)
+{
+    WebKitWebFramePrivate* priv = frame->priv;
+    return priv->webView;
+}
+
+WebCore::Frame* core(WebKitWebFrame* frame)
+{
+    if (!frame)
+        return 0;
+
+    WebKitWebFramePrivate* priv = frame->priv;
+    return priv ? priv->coreFrame.get() : 0;
+}
+
+WebKitWebFrame* kit(WebCore::Frame* coreFrame)
+{
+    if (!coreFrame)
+        return 0;
+
+    ASSERT(coreFrame->loader());
+    WebKit::FrameLoaderClient* client = static_cast<WebKit::FrameLoaderClient*>(coreFrame->loader()->client());
+    return client ? client->webFrame() : 0;
+}
+
+WebCore::Page* core(WebKitWebView* webView)
+{
+    if (!webView)
+        return 0;
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    return priv ? priv->corePage : 0;
+}
+
+WebKitWebView* kit(WebCore::Page* corePage)
+{
+    if (!corePage)
+        return 0;
+
+    ASSERT(corePage->chrome());
+    WebKit::ChromeClient* client = static_cast<WebKit::ChromeClient*>(corePage->chrome()->client());
+    return client ? client->webView() : 0;
+}
+
+} /** end namespace WebCore */
+
+void webkit_init()
+{
+    static bool isInitialized = false;
+    if (isInitialized)
+        return;
+    isInitialized = true;
+
+    WebCore::initializeThreadingAndMainThread();
+    WebCore::InitializeLoggingChannelsIfNecessary();
+
+#if ENABLE(DATABASE)
+    // FIXME: It should be possible for client applications to override this default location
+    gchar* databaseDirectory = g_build_filename(g_get_user_data_dir(), "webkit", "databases", NULL);
+    WebCore::DatabaseTracker::tracker().setDatabaseDirectoryPath(databaseDirectory);
+    g_free(databaseDirectory);
+#endif
+
+    Pasteboard::generalPasteboard()->setHelper(new WebKit::PasteboardHelperGtk());
+}
diff --git a/WebKit/gtk/webkit/webkitprivate.h b/WebKit/gtk/webkit/webkitprivate.h
new file mode 100644
index 0000000..5c75928
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitprivate.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2007, 2008 Holger Hans Peter Freyther
+ * Copyrifht (C) 2008 Jan Michael C. Alonzo
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_PRIVATE_H
+#define WEBKIT_PRIVATE_H
+
+/*
+ * This file knows the shared secret of WebKitWebView and WebKitWebFrame.
+ * They are using WebCore which musn't be exposed to the outer world.
+ */
+
+#include <webkit/webkitdefines.h>
+#include <webkit/webkitwebview.h>
+#include <webkit/webkitwebframe.h>
+#include <webkit/webkitwebsettings.h>
+#include <webkit/webkitnetworkrequest.h>
+#include <webkit/webkitwebbackforwardlist.h>
+
+#include "BackForwardList.h"
+#include "HistoryItem.h"
+#include "Settings.h"
+#include "Page.h"
+#include "Frame.h"
+#include "FrameLoaderClient.h"
+
+#include <glib.h>
+
+namespace WebKit {
+    WebKitWebView* getViewFromFrame(WebKitWebFrame*);
+
+    WebCore::Frame* core(WebKitWebFrame*);
+    WebKitWebFrame* kit(WebCore::Frame*);
+
+    WebCore::Page* core(WebKitWebView*);
+    WebKitWebView* kit(WebCore::Page*);
+
+    WebCore::HistoryItem* core(WebKitWebHistoryItem*);
+    WebKitWebHistoryItem* kit(WebCore::HistoryItem*);
+
+    WebCore::BackForwardList* core(WebKitWebBackForwardList*);
+}
+
+extern "C" {
+    void webkit_init();
+
+#define WEBKIT_PARAM_READABLE ((GParamFlags)(G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB))
+#define WEBKIT_PARAM_READWRITE ((GParamFlags)(G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB))
+
+    #define WEBKIT_WEB_VIEW_GET_PRIVATE(obj)    (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_VIEW, WebKitWebViewPrivate))
+    typedef struct _WebKitWebViewPrivate WebKitWebViewPrivate;
+    struct _WebKitWebViewPrivate {
+        WebCore::Page* corePage;
+        WebKitWebSettings* webSettings;
+
+        WebKitWebFrame* mainFrame;
+        WebCore::String applicationNameForUserAgent;
+        WebCore::String* userAgent;
+
+        WebKitWebBackForwardList* backForwardList;
+
+        gint lastPopupXPosition;
+        gint lastPopupYPosition;
+
+        HashSet<GtkWidget*> children;
+        bool editable;
+        GtkIMContext* imContext;
+
+        GtkTargetList* copy_target_list;
+        GtkTargetList* paste_target_list;
+
+        gboolean transparent;
+    };
+
+    #define WEBKIT_WEB_FRAME_GET_PRIVATE(obj)    (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_FRAME, WebKitWebFramePrivate))
+    typedef struct _WebKitWebFramePrivate WebKitWebFramePrivate;
+    struct _WebKitWebFramePrivate {
+        WTF::RefPtr<WebCore::Frame> coreFrame;
+        WebCore::FrameLoaderClient* client;
+        WebKitWebView* webView;
+
+        gchar* name;
+        gchar* title;
+        gchar* uri;
+    };
+
+    #define WEBKIT_NETWORK_REQUEST_GET_PRIVATE(obj)    (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_NETWORK_REQUEST, WebKitNetworkRequestPrivate))
+    typedef struct _WebKitNetworkRequestPrivate WebKitNetworkRequestPrivate;
+    struct _WebKitNetworkRequestPrivate {
+        gchar* uri;
+    };
+
+    WebKitWebFrame*
+    webkit_web_frame_init_with_web_view(WebKitWebView*, WebCore::HTMLFrameOwnerElement*);
+
+    WebKitWebHistoryItem*
+    webkit_web_history_item_new_with_core_item(WebCore::HistoryItem*);
+
+    // FIXME: Move these to webkitwebframe.h once their API has been discussed.
+
+    WEBKIT_API GSList*
+    webkit_web_frame_get_children (WebKitWebFrame* frame);
+
+    WEBKIT_API gchar*
+    webkit_web_frame_get_inner_text (WebKitWebFrame* frame);
+
+    WEBKIT_API void
+    webkit_web_frame_print (WebKitWebFrame* frame);
+
+    WEBKIT_API gchar*
+    webkit_web_view_get_selected_text (WebKitWebView* web_view);
+}
+
+#endif
diff --git a/WebKit/gtk/webkit/webkitwebbackforwardlist.cpp b/WebKit/gtk/webkit/webkitwebbackforwardlist.cpp
new file mode 100644
index 0000000..c409557
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebbackforwardlist.cpp
@@ -0,0 +1,379 @@
+/*
+ * Copyright (C) 2008 Jan Michael C. Alonzo
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include "webkitwebbackforwardlist.h"
+#include "webkitprivate.h"
+#include "webkitwebhistoryitem.h"
+#include "webkitwebview.h"
+
+#include <glib.h>
+
+#include "BackForwardList.h"
+#include "HistoryItem.h"
+
+using namespace WebKit;
+
+extern "C" {
+
+struct _WebKitWebBackForwardListPrivate {
+    WebCore::BackForwardList* backForwardList;
+};
+
+#define WEBKIT_WEB_BACK_FORWARD_LIST_GET_PRIVATE(obj)    (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_BACK_FORWARD_LIST, WebKitWebBackForwardListPrivate))
+
+G_DEFINE_TYPE(WebKitWebBackForwardList, webkit_web_back_forward_list, G_TYPE_OBJECT);
+
+static void webkit_web_back_forward_list_class_init(WebKitWebBackForwardListClass* klass)
+{
+    g_type_class_add_private(klass, sizeof(WebKitWebBackForwardListPrivate));
+}
+
+static void webkit_web_back_forward_list_init(WebKitWebBackForwardList* webBackForwardList)
+{
+    webBackForwardList->priv = WEBKIT_WEB_BACK_FORWARD_LIST_GET_PRIVATE(webBackForwardList);
+}
+
+/**
+ * webkit_web_back_forward_list_new_with_web_view:
+ * @webView: the back forward list's #WebKitWebView
+ *
+ * Creates an instance of the back forward list with a controlling #WebKitWebView
+ *
+ * Return value: a #WebKitWebBackForwardList
+ */
+WebKitWebBackForwardList* webkit_web_back_forward_list_new_with_web_view(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebBackForwardList* webBackForwardList;
+
+    webBackForwardList = WEBKIT_WEB_BACK_FORWARD_LIST(g_object_new(WEBKIT_TYPE_WEB_BACK_FORWARD_LIST, NULL));
+    WebKitWebBackForwardListPrivate* priv = webBackForwardList->priv;
+
+    priv->backForwardList = core(webView)->backForwardList();
+    priv->backForwardList->setEnabled(TRUE);
+
+    return webBackForwardList;
+}
+
+/**
+ * webkit_web_back_forward_list_go_forward:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Steps forward in the back forward list
+ */
+void webkit_web_back_forward_list_go_forward(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList));
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (backForwardList->enabled())
+        backForwardList->goForward();
+}
+
+/**
+ * webkit_web_back_forward_list_go_back:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Steps backward in the back forward list
+ */
+void webkit_web_back_forward_list_go_back(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList));
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (backForwardList->enabled())
+        backForwardList->goBack();
+}
+
+/**
+ * webkit_web_back_forward_list_contains_item:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ * @webHistoryItem: the #WebKitWebHistoryItem to check
+ *
+ * Checks if @webHistoryItem is in the back forward list
+ *
+ * Return: %TRUE if @webHistoryItem is in the back forward list, %FALSE if it doesn't
+ */
+gboolean webkit_web_back_forward_list_contains_item(WebKitWebBackForwardList* webBackForwardList, WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), FALSE);
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), FALSE);
+
+    WebCore::HistoryItem* historyItem = core(webHistoryItem);
+
+    g_return_val_if_fail(historyItem != NULL, FALSE);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+
+    return (backForwardList->enabled() ? backForwardList->containsItem(historyItem) : FALSE);
+}
+
+/**
+ * webkit_web_back_forward_list_go_to_item:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ * @webHistoryItem: the #WebKitWebHistoryItem to go to
+ *
+ * Go to the specified @webHistoryItem in the back forward list
+ */
+void webkit_web_back_forward_list_go_to_item(WebKitWebBackForwardList* webBackForwardList, WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList));
+    g_return_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem));
+
+    WebCore::HistoryItem* historyItem = core(webHistoryItem);
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+
+    if (backForwardList->enabled() && historyItem)
+        backForwardList->goToItem(historyItem);
+}
+
+/**
+ * webkit_web_back_forward_list_get_forward_list_with_limit:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ * @limit: the number of items to retrieve
+ *
+ * Returns a list of items that succeed the current item, limited by @limit
+ *
+ * Return value: a #GList of items succeeding the current item, limited by @limit
+ */
+GList* webkit_web_back_forward_list_get_forward_list_with_limit(WebKitWebBackForwardList* webBackForwardList, gint limit)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return NULL;
+
+    WebCore::HistoryItemVector items(limit);
+    GList* forwardItems = { 0 };
+
+    backForwardList->forwardListWithLimit(limit, items);
+
+    for (unsigned i = 0; i < items.size(); i++) {
+        WebKitWebHistoryItem* webHistoryItem = webkit_web_history_item_new_with_core_item(items[i].get());
+        forwardItems = g_list_prepend(forwardItems, g_object_ref(webHistoryItem));
+    }
+
+    return g_list_reverse(forwardItems);
+}
+
+/**
+ * webkit_web_back_forward_list_get_back_list_with_limit:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ * @limit: the number of items to retrieve
+ *
+ * Returns a list of items that precede the current item, limited by @limit
+ *
+ * Return value: a #GList of items preceding the current item, limited by @limit
+ */
+GList* webkit_web_back_forward_list_get_back_list_with_limit(WebKitWebBackForwardList* webBackForwardList, gint limit)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return NULL;
+
+    WebCore::HistoryItemVector items(limit);
+    GList* backItems = { 0 };
+
+    backForwardList->backListWithLimit(limit, items);
+
+    for (unsigned i = 0; i < items.size(); i++) {
+        WebKitWebHistoryItem* webHistoryItem = webkit_web_history_item_new_with_core_item(items[i].get());
+        backItems = g_list_prepend(backItems, g_object_ref(webHistoryItem));
+    }
+
+    return g_list_reverse(backItems);
+}
+/**
+ * webkit_web_back_forward_list_get_back_item:
+ * @webBackForwardList: a #WebBackForwardList
+ *
+ * Returns the item that precedes the current item
+ *
+ * Return value: the #WebKitWebHistoryItem preceding the current item
+ */
+WebKitWebHistoryItem* webkit_web_back_forward_list_get_back_item(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return NULL;
+
+    WebCore::HistoryItem* historyItem = backForwardList->backItem();
+
+    return (historyItem ? kit(historyItem) : NULL);
+}
+
+/**
+ * webkit_web_back_forward_list_get_current_item:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Returns the current item.
+ *
+ * Returns a NULL value if the back forward list is empty
+ *
+ * Return value: a #WebKitWebHistoryItem
+ */
+WebKitWebHistoryItem* webkit_web_back_forward_list_get_current_item(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return NULL;
+
+    WebCore::HistoryItem* historyItem = backForwardList->currentItem();
+
+    return (historyItem ? kit(historyItem) : NULL);
+}
+
+/**
+ * webkit_web_back_forward_list_get_forward_item:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Returns the item that succeeds the current item.
+ *
+ * Returns a NULL value if there nothing that succeeds the current item
+ *
+ * Return value: a #WebKitWebHistoryItem
+ */
+WebKitWebHistoryItem* webkit_web_back_forward_list_get_forward_item(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return NULL;
+
+    WebCore::HistoryItem* historyItem = backForwardList->forwardItem();
+
+    return (historyItem ? kit(historyItem) : NULL);
+}
+
+/**
+ * webkit_web_back_forward_list_get_nth_item:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ * @index: the index of the item
+ *
+ * Returns the item at a given index relative to the current item.
+ *
+ * Return value: the #WebKitWebHistoryItem located at the specified index relative to the current item
+ */
+WebKitWebHistoryItem* webkit_web_back_forward_list_get_nth_item(WebKitWebBackForwardList* webBackForwardList, gint index)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList)
+        return NULL;
+
+    WebCore::HistoryItem* historyItem = backForwardList->itemAtIndex(index);
+
+    return (historyItem ? kit(historyItem) : NULL);
+}
+
+/**
+ * webkit_web_back_forward_list_get_back_length:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Returns the number of items that preced the current item.
+ *
+ * Return value: a #gint corresponding to the number of items preceding the current item
+ */
+gint webkit_web_back_forward_list_get_back_length(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), 0);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return 0;
+
+    return backForwardList->backListCount();
+}
+
+/**
+ * webkit_web_back_forward_list_get_forward_length:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Returns the number of items that succeed the current item.
+ *
+ * Return value: a #gint corresponding to the nuber of items succeeding the current item
+ */
+gint webkit_web_back_forward_list_get_forward_length(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), 0);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return 0;
+
+    return backForwardList->forwardListCount();
+}
+
+/**
+ * webkit_web_back_forward_list_get_capacity:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ *
+ * Returns the maximum limit of the back forward list.
+ *
+ * Return value: a #gint indicating the number of #WebHistoryItem the back forward list can hold
+ */
+gint webkit_web_back_forward_list_get_limit(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), 0);
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (!backForwardList || !backForwardList->enabled())
+        return 0;
+
+    return backForwardList->capacity();
+}
+
+/**
+ * webkit_web_back_forward_list_set_limit:
+ * @webBackForwardList: a #WebKitWebBackForwardList
+ * @limit: the limit to set the back forward list to
+ *
+ * Sets the maximum limit of the back forward list. If the back forward list
+ * exceeds its capacity, items will be removed everytime a new item has been
+ * added.
+ */
+void webkit_web_back_forward_list_set_limit(WebKitWebBackForwardList* webBackForwardList, gint limit)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList));
+
+    WebCore::BackForwardList* backForwardList = core(webBackForwardList);
+    if (backForwardList)
+        backForwardList->setCapacity(limit);
+}
+
+} /* end extern "C" */
+
+WebCore::BackForwardList* WebKit::core(WebKitWebBackForwardList* webBackForwardList)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_BACK_FORWARD_LIST(webBackForwardList), NULL);
+
+    return webBackForwardList->priv ? webBackForwardList->priv->backForwardList : 0;
+}
diff --git a/WebKit/gtk/webkit/webkitwebbackforwardlist.h b/WebKit/gtk/webkit/webkitwebbackforwardlist.h
new file mode 100644
index 0000000..e63505d
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebbackforwardlist.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2008 Jan Michael C. Alonzo <jmalonzo@unpluggable.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_WEB_BACK_FORWARD_LIST_H
+#define WEBKIT_WEB_BACK_FORWARD_LIST_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <webkit/webkitdefines.h>
+#include <webkit/webkitwebhistoryitem.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_WEB_BACK_FORWARD_LIST            (webkit_web_back_forward_list_get_type())
+#define WEBKIT_WEB_BACK_FORWARD_LIST(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_WEB_BACK_FORWARD_LIST, WebKitWebBackForwardList))
+#define WEBKIT_WEB_BACK_FORWARD_LIST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_WEB_BACK_FORWARD_LIST, WebKitWebBackForwardListClass))
+#define WEBKIT_IS_WEB_BACK_FORWARD_LIST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_WEB_BACK_FORWARD_LIST))
+#define WEBKIT_IS_WEB_BACK_FORWARD_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_WEB_BACK_FORWARD_LIST))
+#define WEBKIT_WEB_BACK_FORWARD_LIST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_WEB_BACK_FORWARD_LIST, WebKitWebBackForwardListClass))
+
+typedef struct _WebKitWebBackForwardListPrivate WebKitWebBackForwardListPrivate;
+
+struct _WebKitWebBackForwardList {
+    GObject parent_instance;
+
+    WebKitWebBackForwardListPrivate* priv;
+};
+
+struct _WebKitWebBackForwardListClass {
+    GObjectClass parent_class;
+};
+
+WEBKIT_API GType
+webkit_web_back_forward_list_get_type (void);
+
+WEBKIT_API WebKitWebBackForwardList*
+webkit_web_back_forward_list_new_with_web_view (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_back_forward_list_go_forward (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API void
+webkit_web_back_forward_list_go_back (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API gboolean
+webkit_web_back_forward_list_contains_item (WebKitWebBackForwardList* web_back_forward_list, WebKitWebHistoryItem* history_item);
+
+WEBKIT_API void
+webkit_web_back_forward_list_go_to_item (WebKitWebBackForwardList* web_back_forward_list, WebKitWebHistoryItem* history_item);
+
+WEBKIT_API GList*
+webkit_web_back_forward_list_get_forward_list_with_limit (WebKitWebBackForwardList* web_back_forward_list, gint limit);
+
+WEBKIT_API GList*
+webkit_web_back_forward_list_get_back_list_with_limit (WebKitWebBackForwardList* web_back_forward_list, gint limit);
+
+WEBKIT_API WebKitWebHistoryItem*
+webkit_web_back_forward_list_get_back_item (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API WebKitWebHistoryItem*
+webkit_web_back_forward_list_get_current_item (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API WebKitWebHistoryItem*
+webkit_web_back_forward_list_get_forward_item (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API WebKitWebHistoryItem*
+webkit_web_back_forward_list_get_nth_item (WebKitWebBackForwardList* web_back_forward_list, gint index);
+
+WEBKIT_API gint
+webkit_web_back_forward_list_get_back_length (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API gint
+webkit_web_back_forward_list_get_forward_length (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API gint
+webkit_web_back_forward_list_get_limit (WebKitWebBackForwardList* web_back_forward_list);
+
+WEBKIT_API void
+webkit_web_back_forward_list_set_limit (WebKitWebBackForwardList* web_back_forward_list, gint limit);
+
+G_END_DECLS
+
+
+#endif /* WEBKIT_WEB_BACK_FORWARD_LIST_H */
diff --git a/WebKit/gtk/webkit/webkitwebframe.cpp b/WebKit/gtk/webkit/webkitwebframe.cpp
new file mode 100644
index 0000000..0201f5c
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebframe.cpp
@@ -0,0 +1,690 @@
+/*
+ * Copyright (C) 2007, 2008 Holger Hans Peter Freyther
+ * Copyright (C) 2007 Alp Toker <alp@atoker.com>
+ * Copyright (C) 2007 Apple Inc.
+ * Copyright (C) 2008 Christian Dywan <christian@imendio.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include "webkitwebframe.h"
+#include "webkitwebview.h"
+#include "webkit-marshal.h"
+#include "webkitprivate.h"
+
+#include "CString.h"
+#include "FrameLoader.h"
+#include "FrameLoaderClientGtk.h"
+#include "FrameTree.h"
+#include "FrameView.h"
+#include "GraphicsContext.h"
+#include "HTMLFrameOwnerElement.h"
+#include "RenderView.h"
+#include "kjs_binding.h"
+#include "kjs_proxy.h"
+#include "kjs_window.h"
+
+#include <JavaScriptCore/APICast.h>
+
+using namespace WebKit;
+using namespace WebCore;
+using namespace std;
+
+extern "C" {
+
+enum {
+    CLEARED,
+    LOAD_COMMITTED,
+    LOAD_DONE,
+    TITLE_CHANGED,
+    HOVERING_OVER_LINK,
+    LAST_SIGNAL
+};
+
+enum {
+    PROP_0,
+
+    PROP_NAME,
+    PROP_TITLE,
+    PROP_URI
+};
+
+static guint webkit_web_frame_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE(WebKitWebFrame, webkit_web_frame, G_TYPE_OBJECT)
+
+static void webkit_web_frame_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
+{
+    WebKitWebFrame* frame = WEBKIT_WEB_FRAME(object);
+
+    switch(prop_id) {
+    case PROP_NAME:
+        g_value_set_string(value, webkit_web_frame_get_name(frame));
+        break;
+    case PROP_TITLE:
+        g_value_set_string(value, webkit_web_frame_get_title(frame));
+        break;
+    case PROP_URI:
+        g_value_set_string(value, webkit_web_frame_get_uri(frame));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
+}
+
+static void webkit_web_frame_finalize(GObject* object)
+{
+    WebKitWebFrame* frame = WEBKIT_WEB_FRAME(object);
+    WebKitWebFramePrivate* priv = frame->priv;
+
+    priv->coreFrame->loader()->cancelAndClear();
+    priv->coreFrame = 0;
+
+    g_free(priv->name);
+    g_free(priv->title);
+    g_free(priv->uri);
+
+    G_OBJECT_CLASS(webkit_web_frame_parent_class)->finalize(object);
+}
+
+static void webkit_web_frame_class_init(WebKitWebFrameClass* frameClass)
+{
+    webkit_init();
+
+    /*
+     * signals
+     */
+    webkit_web_frame_signals[CLEARED] = g_signal_new("cleared",
+            G_TYPE_FROM_CLASS(frameClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    webkit_web_frame_signals[LOAD_COMMITTED] = g_signal_new("load-committed",
+            G_TYPE_FROM_CLASS(frameClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    webkit_web_frame_signals[LOAD_DONE] = g_signal_new("load-done",
+            G_TYPE_FROM_CLASS(frameClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__BOOLEAN,
+            G_TYPE_NONE, 1,
+            G_TYPE_BOOLEAN);
+
+    webkit_web_frame_signals[TITLE_CHANGED] = g_signal_new("title-changed",
+            G_TYPE_FROM_CLASS(frameClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            webkit_marshal_VOID__STRING,
+            G_TYPE_NONE, 1,
+            G_TYPE_STRING);
+
+    webkit_web_frame_signals[HOVERING_OVER_LINK] = g_signal_new("hovering-over-link",
+            G_TYPE_FROM_CLASS(frameClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            webkit_marshal_VOID__STRING_STRING,
+            G_TYPE_NONE, 2,
+            G_TYPE_STRING, G_TYPE_STRING);
+
+    /*
+     * implementations of virtual methods
+     */
+    GObjectClass* objectClass = G_OBJECT_CLASS(frameClass);
+    objectClass->finalize = webkit_web_frame_finalize;
+    objectClass->get_property = webkit_web_frame_get_property;
+
+    /*
+     * properties
+     */
+    g_object_class_install_property(objectClass, PROP_NAME,
+                                    g_param_spec_string("name",
+                                                        "Name",
+                                                        "The name of the frame",
+                                                        NULL,
+                                                        WEBKIT_PARAM_READABLE));
+
+    g_object_class_install_property(objectClass, PROP_TITLE,
+                                    g_param_spec_string("title",
+                                                        "Title",
+                                                        "The document title of the frame",
+                                                        NULL,
+                                                        WEBKIT_PARAM_READABLE));
+
+    g_object_class_install_property(objectClass, PROP_URI,
+                                    g_param_spec_string("uri",
+                                                        "URI",
+                                                        "The current URI of the contents displayed by the frame",
+                                                        NULL,
+                                                        WEBKIT_PARAM_READABLE));
+
+    g_type_class_add_private(frameClass, sizeof(WebKitWebFramePrivate));
+}
+
+static void webkit_web_frame_init(WebKitWebFrame* frame)
+{
+    WebKitWebFramePrivate* priv = WEBKIT_WEB_FRAME_GET_PRIVATE(frame);
+
+    // TODO: Move constructor code here.
+    frame->priv = priv;
+}
+
+/**
+ * webkit_web_frame_new:
+ * @web_view: the controlling #WebKitWebView
+ *
+ * Creates a new #WebKitWebFrame initialized with a controlling #WebKitWebView.
+ *
+ * Returns: a new #WebKitWebFrame
+ **/
+WebKitWebFrame* webkit_web_frame_new(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebFrame* frame = WEBKIT_WEB_FRAME(g_object_new(WEBKIT_TYPE_WEB_FRAME, NULL));
+    WebKitWebFramePrivate* priv = frame->priv;
+    WebKitWebViewPrivate* viewPriv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
+
+    priv->client = new WebKit::FrameLoaderClient(frame);
+    priv->coreFrame = new Frame(viewPriv->corePage, 0, priv->client);
+
+    FrameView* frameView = new FrameView(priv->coreFrame.get());
+    frameView->setContainingWindow(GTK_CONTAINER(webView));
+    frameView->setGtkAdjustments(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)),
+                                 GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
+    priv->coreFrame->setView(frameView);
+    frameView->deref();
+    priv->coreFrame->init();
+    priv->webView = webView;
+
+    return frame;
+}
+
+WebKitWebFrame* webkit_web_frame_init_with_web_view(WebKitWebView* webView, HTMLFrameOwnerElement* element)
+{
+    WebKitWebFrame* frame = WEBKIT_WEB_FRAME(g_object_new(WEBKIT_TYPE_WEB_FRAME, NULL));
+    WebKitWebFramePrivate* priv = frame->priv;
+    WebKitWebViewPrivate* viewPriv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
+
+    priv->client = new WebKit::FrameLoaderClient(frame);
+    priv->coreFrame = new Frame(viewPriv->corePage, element, priv->client);
+
+    FrameView* frameView = new FrameView(priv->coreFrame.get());
+    frameView->setContainingWindow(GTK_CONTAINER(webView));
+    priv->coreFrame->setView(frameView);
+    frameView->deref();
+    priv->coreFrame->init();
+    priv->webView = webView;
+
+    return frame;
+}
+
+/**
+ * webkit_web_frame_get_title:
+ * @frame: a #WebKitWebFrame
+ *
+ * Returns the @frame's document title
+ *
+ * Return value: the title of @frame
+ */
+const gchar* webkit_web_frame_get_title(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    WebKitWebFramePrivate* priv = frame->priv;
+    return priv->title;
+}
+
+/**
+ * webkit_web_frame_get_uri:
+ * @frame: a #WebKitWebFrame
+ *
+ * Returns the current URI of the contents displayed by the @frame
+ *
+ * Return value: the URI of @frame
+ */
+const gchar* webkit_web_frame_get_uri(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    WebKitWebFramePrivate* priv = frame->priv;
+    return priv->uri;
+}
+
+/**
+ * webkit_web_frame_get_web_view:
+ * @frame: a #WebKitWebFrame
+ *
+ * Returns the #WebKitWebView that manages this #WebKitWebFrame.
+ *
+ * The #WebKitWebView returned manages the entire hierarchy of #WebKitWebFrame
+ * objects that contains @frame.
+ *
+ * Return value: the #WebKitWebView that manages @frame
+ */
+WebKitWebView* webkit_web_frame_get_web_view(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    WebKitWebFramePrivate* priv = frame->priv;
+    return priv->webView;
+}
+
+/**
+ * webkit_web_frame_get_name:
+ * @frame: a #WebKitWebFrame
+ *
+ * Returns the @frame's name
+ *
+ * Return value: the name of @frame
+ */
+const gchar* webkit_web_frame_get_name(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    WebKitWebFramePrivate* priv = frame->priv;
+
+    if (priv->name)
+        return priv->name;
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    String string = coreFrame->tree()->name();
+    priv->name = g_strdup(string.utf8().data());
+    return priv->name;
+}
+
+/**
+ * webkit_web_frame_get_parent:
+ * @frame: a #WebKitWebFrame
+ *
+ * Returns the @frame's parent frame, or %NULL if it has none.
+ *
+ * Return value: the parent #WebKitWebFrame or %NULL in case there is none
+ */
+WebKitWebFrame* webkit_web_frame_get_parent(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    return kit(coreFrame->tree()->parent());
+}
+
+/**
+ * webkit_web_frame_load_request:
+ * @frame: a #WebKitWebFrame
+ * @request: a #WebKitNetworkRequest
+ *
+ * Connects to a given URI by initiating an asynchronous client request.
+ *
+ * Creates a provisional data source that will transition to a committed data
+ * source once any data has been received. Use webkit_web_frame_stop_loading() to
+ * stop the load. This function is typically invoked on the main frame.
+ */
+void webkit_web_frame_load_request(WebKitWebFrame* frame, WebKitNetworkRequest* request)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
+    g_return_if_fail(WEBKIT_IS_NETWORK_REQUEST(request));
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    // TODO: Use the ResourceRequest carried by WebKitNetworkRequest when it is implemented.
+    String string = String::fromUTF8(webkit_network_request_get_uri(request));
+    coreFrame->loader()->load(ResourceRequest(KURL(string)));
+}
+
+/**
+ * webkit_web_frame_stop_loading:
+ * @frame: a #WebKitWebFrame
+ *
+ * Stops any pending loads on @frame's data source, and those of its children.
+ */
+void webkit_web_frame_stop_loading(WebKitWebFrame* frame)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    coreFrame->loader()->stopAllLoaders();
+}
+
+/**
+ * webkit_web_frame_reload:
+ * @frame: a #WebKitWebFrame
+ *
+ * Reloads the initial request.
+ */
+void webkit_web_frame_reload(WebKitWebFrame* frame)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    coreFrame->loader()->reload();
+}
+
+/**
+ * webkit_web_frame_find_frame:
+ * @frame: a #WebKitWebFrame
+ * @name: the name of the frame to be found
+ *
+ * For pre-defined names, returns @frame if @name is "_self" or "_current",
+ * returns @frame's parent frame if @name is "_parent", and returns the main
+ * frame if @name is "_top". Also returns @frame if it is the main frame and
+ * @name is either "_parent" or "_top". For other names, this function returns
+ * the first frame that matches @name. This function searches @frame and its
+ * descendents first, then @frame's parent and its children moving up the
+ * hierarchy until a match is found. If no match is found in @frame's
+ * hierarchy, this function will search for a matching frame in other main
+ * frame hierarchies. Returns %NULL if no match is found.
+ *
+ * Return value: the found #WebKitWebFrame or %NULL in case none is found
+ */
+WebKitWebFrame* webkit_web_frame_find_frame(WebKitWebFrame* frame, const gchar* name)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+    g_return_val_if_fail(name, NULL);
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    String nameString = String::fromUTF8(name);
+    return kit(coreFrame->tree()->find(AtomicString(nameString)));
+}
+
+/**
+ * webkit_web_frame_get_global_context:
+ * @frame: a #WebKitWebFrame
+ *
+ * Gets the global JavaScript execution context. Use this function to bridge
+ * between the WebKit and JavaScriptCore APIs.
+ *
+ * Return value: the global JavaScript context
+ */
+JSGlobalContextRef webkit_web_frame_get_global_context(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    return toGlobalRef(coreFrame->scriptProxy()->globalObject()->globalExec());
+}
+
+/**
+ * webkit_web_frame_get_children:
+ * @frame: a #WebKitWebFrame
+ *
+ * Return value: child frames of @frame
+ */
+GSList* webkit_web_frame_get_children(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    GSList* children = NULL;
+    for (Frame* child = coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
+        FrameLoader* loader = child->loader();
+        WebKit::FrameLoaderClient* client = static_cast<WebKit::FrameLoaderClient*>(loader->client());
+        if (client)
+          children = g_slist_append(children, client->webFrame());
+    }
+
+    return children;
+}
+
+/**
+ * webkit_web_frame_get_inner_text:
+ * @frame: a #WebKitWebFrame
+ *
+ * Return value: inner text of @frame
+ */
+gchar* webkit_web_frame_get_inner_text(WebKitWebFrame* frame)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    FrameView* view = coreFrame->view();
+
+    if (view->layoutPending())
+        view->layout();
+
+    Element* documentElement = coreFrame->document()->documentElement();
+    String string =  documentElement->innerText();
+    return g_strdup(string.utf8().data());
+}
+
+#if GTK_CHECK_VERSION(2,10,0)
+
+// This could be shared between ports once it's complete
+class PrintContext
+{
+public:
+    PrintContext(Frame* frame)
+        : m_frame(frame)
+    {
+    }
+
+    ~PrintContext()
+    {
+        m_pageRects.clear();
+    }
+
+    int pageCount()
+    {
+        return m_pageRects.size();
+    }
+
+    void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
+    {
+        m_pageRects.clear();
+        outPageHeight = 0;
+
+        if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
+            return;
+
+        RenderView* root = static_cast<RenderView*>(m_frame->document()->renderer());
+
+        if (!root) {
+            LOG_ERROR("document to be printed has no renderer");
+            return;
+        }
+
+        if (userScaleFactor <= 0) {
+            LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
+            return;
+        }
+
+        float ratio = printRect.height() / printRect.width();
+
+        float pageWidth  = (float)root->docWidth();
+        float pageHeight = pageWidth * ratio;
+        outPageHeight = pageHeight;   // this is the height of the page adjusted by margins
+        pageHeight -= headerHeight + footerHeight;
+
+        if (pageHeight <= 0) {
+            LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
+            return;
+        }
+
+        float currPageHeight = pageHeight / userScaleFactor;
+        float docHeight = root->layer()->height();
+        float currPageWidth = pageWidth / userScaleFactor;
+
+        // always return at least one page, since empty files should print a blank page
+        float printedPagesHeight = 0.0;
+        do {
+            float proposedBottom = min(docHeight, printedPagesHeight + pageHeight);
+            m_frame->adjustPageHeight(&proposedBottom, printedPagesHeight, proposedBottom, printedPagesHeight);
+            currPageHeight = max(1.0f, proposedBottom - printedPagesHeight);
+
+            m_pageRects.append(IntRect(0, (int)printedPagesHeight, (int)currPageWidth, (int)currPageHeight));
+            printedPagesHeight += currPageHeight;
+        } while (printedPagesHeight < docHeight);
+    }
+
+    // TODO: eliminate width param
+    void begin(float width)
+    {
+        // By imaging to a width a little wider than the available pixels,
+        // thin pages will be scaled down a little, matching the way they
+        // print in IE and Camino. This lets them use fewer sheets than they
+        // would otherwise, which is presumably why other browsers do this.
+        // Wide pages will be scaled down more than this.
+        const float PrintingMinimumShrinkFactor = 1.25f;
+
+        // This number determines how small we are willing to reduce the page content
+        // in order to accommodate the widest line. If the page would have to be
+        // reduced smaller to make the widest line fit, we just clip instead (this
+        // behavior matches MacIE and Mozilla, at least)
+        const float PrintingMaximumShrinkFactor = 2.0f;
+
+        float minLayoutWidth = width * PrintingMinimumShrinkFactor;
+        float maxLayoutWidth = width * PrintingMaximumShrinkFactor;
+
+        // FIXME: This will modify the rendering of the on-screen frame.
+        // Could lead to flicker during printing.
+        m_frame->setPrinting(true, minLayoutWidth, maxLayoutWidth, true);
+    }
+
+    // TODO: eliminate width param
+    void spoolPage(GraphicsContext& ctx, int pageNumber, float width)
+    {
+        IntRect pageRect = m_pageRects[pageNumber];
+        float scale = width / pageRect.width();
+
+        ctx.save();
+        ctx.scale(FloatSize(scale, scale));
+        ctx.translate(-pageRect.x(), -pageRect.y());
+        ctx.clip(pageRect);
+        m_frame->paint(&ctx, pageRect);
+        ctx.restore();
+    }
+
+    void end()
+    {
+        m_frame->setPrinting(false, 0, 0, true);
+    }
+
+protected:
+    Frame* m_frame;
+    Vector<IntRect> m_pageRects;
+};
+
+static void begin_print(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
+{
+    PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
+
+    float width = gtk_print_context_get_width(context);
+    float height = gtk_print_context_get_height(context);
+    FloatRect printRect = FloatRect(0, 0, width, height);
+
+    printContext->begin(width);
+
+    // TODO: Margin adjustments and header/footer support
+    float headerHeight = 0;
+    float footerHeight = 0;
+    float pageHeight; // height of the page adjusted by margins
+    printContext->computePageRects(printRect, headerHeight, footerHeight, 1.0, pageHeight);
+    gtk_print_operation_set_n_pages(op, printContext->pageCount());
+}
+
+static void draw_page(GtkPrintOperation* op, GtkPrintContext* context, gint page_nr, gpointer user_data)
+{
+    PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
+
+    cairo_t* cr = gtk_print_context_get_cairo_context(context);
+    GraphicsContext ctx(cr);
+    float width = gtk_print_context_get_width(context);
+    printContext->spoolPage(ctx, page_nr, width);
+}
+
+static void end_print(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
+{
+    PrintContext* printContext = reinterpret_cast<PrintContext*>(user_data);
+    printContext->end();
+}
+
+void webkit_web_frame_print(WebKitWebFrame* frame)
+{
+    GtkWidget* topLevel = gtk_widget_get_toplevel(GTK_WIDGET(webkit_web_frame_get_web_view(frame)));
+    if (!GTK_WIDGET_TOPLEVEL(topLevel))
+        topLevel = NULL;
+
+    Frame* coreFrame = core(frame);
+    ASSERT(coreFrame);
+
+    PrintContext printContext(coreFrame);
+
+    GtkPrintOperation* op = gtk_print_operation_new();
+    g_signal_connect(G_OBJECT(op), "begin-print", G_CALLBACK(begin_print), &printContext);
+    g_signal_connect(G_OBJECT(op), "draw-page", G_CALLBACK(draw_page), &printContext);
+    g_signal_connect(G_OBJECT(op), "end-print", G_CALLBACK(end_print), &printContext);
+    GError *error = NULL;
+    gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(topLevel), &error);
+    g_object_unref(op);
+
+    if (error) {
+        GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(topLevel),
+                                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                                   GTK_MESSAGE_ERROR,
+                                                   GTK_BUTTONS_CLOSE,
+                                                   "%s", error->message);
+        g_error_free(error);
+
+        g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);
+        gtk_widget_show(dialog);
+    }
+}
+
+#else
+
+void webkit_web_frame_print(WebKitWebFrame*)
+{
+    g_warning("Printing support is not available in older versions of GTK+");
+}
+
+#endif
+
+}
diff --git a/WebKit/gtk/webkit/webkitwebframe.h b/WebKit/gtk/webkit/webkitwebframe.h
new file mode 100644
index 0000000..a89da46
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebframe.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ * Copyright (C) 2007 Alp Toker <alp@atoker.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_WEB_FRAME_H
+#define WEBKIT_WEB_FRAME_H
+
+#include <glib-object.h>
+#include <JavaScriptCore/JSBase.h>
+
+#include <webkit/webkitdefines.h>
+#include <webkit/webkitnetworkrequest.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_WEB_FRAME            (webkit_web_frame_get_type())
+#define WEBKIT_WEB_FRAME(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_WEB_FRAME, WebKitWebFrame))
+#define WEBKIT_WEB_FRAME_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_WEB_FRAME, WebKitWebFrameClass))
+#define WEBKIT_IS_WEB_FRAME(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_WEB_FRAME))
+#define WEBKIT_IS_WEB_FRAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_WEB_FRAME))
+#define WEBKIT_WEB_FRAME_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_WEB_FRAME, WebKitWebFrameClass))
+
+typedef struct _WebKitWebFramePrivate WebKitWebFramePrivate;
+
+struct _WebKitWebFrame {
+    GObject parent_instance;
+
+    WebKitWebFramePrivate* priv;
+};
+
+struct _WebKitWebFrameClass {
+    GObjectClass parent_class;
+
+    void (*_webkit_reserved1) (void);
+    void (*_webkit_reserved2) (void);
+    void (*_webkit_reserved3) (void);
+    void (*_webkit_reserved4) (void);
+    void (*_webkit_reserved5) (void);
+    void (*_webkit_reserved6) (void);
+};
+
+WEBKIT_API GType
+webkit_web_frame_get_type (void);
+
+WEBKIT_API WebKitWebFrame*
+webkit_web_frame_new (WebKitWebView* web_view);
+
+WEBKIT_API WebKitWebView*
+webkit_web_frame_get_web_view (WebKitWebFrame* frame);
+
+WEBKIT_API const gchar*
+webkit_web_frame_get_name (WebKitWebFrame* frame);
+
+WEBKIT_API const gchar*
+webkit_web_frame_get_title (WebKitWebFrame* frame);
+
+WEBKIT_API const gchar*
+webkit_web_frame_get_uri (WebKitWebFrame* frame);
+
+WEBKIT_API WebKitWebFrame*
+webkit_web_frame_get_parent (WebKitWebFrame* frame);
+
+WEBKIT_API void
+webkit_web_frame_load_request (WebKitWebFrame* frame, WebKitNetworkRequest* request);
+
+WEBKIT_API void
+webkit_web_frame_stop_loading (WebKitWebFrame* frame);
+
+WEBKIT_API void
+webkit_web_frame_reload (WebKitWebFrame* frame);
+
+WEBKIT_API WebKitWebFrame*
+webkit_web_frame_find_frame (WebKitWebFrame* frame, const gchar* name);
+
+WEBKIT_API JSGlobalContextRef
+webkit_web_frame_get_global_context (WebKitWebFrame* frame);
+
+G_END_DECLS
+
+#endif
diff --git a/WebKit/gtk/webkit/webkitwebhistoryitem.cpp b/WebKit/gtk/webkit/webkitwebhistoryitem.cpp
new file mode 100644
index 0000000..d9c8cd0
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebhistoryitem.cpp
@@ -0,0 +1,330 @@
+/*
+ * Copyright (C) 2008 Jan Michael C. Alonzo
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+
+#include "config.h"
+
+#include "webkitwebhistoryitem.h"
+#include "webkitprivate.h"
+
+#include <glib.h>
+
+#include "CString.h"
+#include "HistoryItem.h"
+#include "PlatformString.h"
+
+using namespace WebKit;
+
+extern "C" {
+
+struct _WebKitWebHistoryItemPrivate {
+    WebCore::HistoryItem* historyItem;
+
+    gchar* title;
+    gchar* alternateTitle;
+    gchar* uri;
+    gchar* originalUri;
+};
+
+#define WEBKIT_WEB_HISTORY_ITEM_GET_PRIVATE(obj)    (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_HISTORY_ITEM, WebKitWebHistoryItemPrivate))
+
+G_DEFINE_TYPE(WebKitWebHistoryItem, webkit_web_history_item, G_TYPE_OBJECT);
+
+
+static GHashTable* webkit_history_items()
+{
+    static GHashTable* historyItems = g_hash_table_new(g_direct_hash, g_direct_equal);
+    return historyItems;
+}
+
+static void webkit_history_item_add(WebKitWebHistoryItem* webHistoryItem, WebCore::HistoryItem* historyItem)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem));
+
+    GHashTable* table = webkit_history_items();
+
+    historyItem->ref();
+    g_hash_table_insert(table, historyItem, g_object_ref(webHistoryItem));
+}
+
+static void webkit_history_item_remove(WebCore::HistoryItem* historyItem)
+{
+    GHashTable* table = webkit_history_items();
+    WebKitWebHistoryItem* webHistoryItem = (WebKitWebHistoryItem*) g_hash_table_lookup(table, historyItem);
+
+    g_return_if_fail(webHistoryItem != NULL);
+
+    g_hash_table_remove(table, historyItem);
+    historyItem->deref();
+    g_object_unref(webHistoryItem);
+}
+
+static void webkit_web_history_item_dispose(GObject* object)
+{
+    WebKitWebHistoryItem* webHistoryItem = WEBKIT_WEB_HISTORY_ITEM(object);
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+
+    webkit_history_item_remove(priv->historyItem);
+    delete priv->historyItem;
+
+    /* destroy table if empty */
+    GHashTable* table = webkit_history_items();
+    if (!g_hash_table_size(table))
+        g_hash_table_destroy(table);
+
+    G_OBJECT_CLASS(webkit_web_history_item_parent_class)->dispose(object);
+}
+
+static void webkit_web_history_item_finalize(GObject* object)
+{
+    WebKitWebHistoryItem* webHistoryItem = WEBKIT_WEB_HISTORY_ITEM(object);
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+
+    g_free(priv->title);
+    g_free(priv->alternateTitle);
+    g_free(priv->uri);
+    g_free(priv->originalUri);
+
+    G_OBJECT_CLASS(webkit_web_history_item_parent_class)->finalize(object);
+}
+
+static void webkit_web_history_item_class_init(WebKitWebHistoryItemClass* klass)
+{
+    GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
+
+    gobject_class->dispose = webkit_web_history_item_dispose;
+    gobject_class->finalize = webkit_web_history_item_finalize;
+
+    g_type_class_add_private(gobject_class, sizeof(WebKitWebHistoryItemPrivate));
+}
+
+static void webkit_web_history_item_init(WebKitWebHistoryItem* webHistoryItem)
+{
+    webHistoryItem->priv = WEBKIT_WEB_HISTORY_ITEM_GET_PRIVATE(webHistoryItem);
+}
+
+/* Helper function to create a new WebHistoryItem instance when needed */
+WebKitWebHistoryItem* webkit_web_history_item_new_with_core_item(WebCore::HistoryItem* item)
+{
+    WebKitWebHistoryItem* webHistoryItem = kit(item);
+
+    if (!webHistoryItem) {
+        webHistoryItem = WEBKIT_WEB_HISTORY_ITEM(g_object_new(WEBKIT_TYPE_WEB_HISTORY_ITEM, NULL));
+        WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+        priv->historyItem = item;
+        webkit_history_item_add(webHistoryItem, priv->historyItem);
+    }
+
+    return webHistoryItem;
+}
+
+
+/**
+ * webkit_web_history_item_new:
+ *
+ * Creates a new #WebKitWebHistoryItem instance
+ *
+ * Return value: the new #WebKitWebHistoryItem
+ */
+WebKitWebHistoryItem* webkit_web_history_item_new(void)
+{
+    WebKitWebHistoryItem* webHistoryItem = WEBKIT_WEB_HISTORY_ITEM(g_object_new(WEBKIT_TYPE_WEB_HISTORY_ITEM, NULL));
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+
+    priv->historyItem = new WebCore::HistoryItem();
+    webkit_history_item_add(webHistoryItem, priv->historyItem);
+
+    return webHistoryItem;
+}
+
+/**
+ * webkit_web_history_item_new_with_data:
+ * @uri: the uri of the page
+ * @title: the title of the page
+ *
+ * Creates a new #WebKitWebHistoryItem with the given URI and title
+ *
+ * Return value: the new #WebKitWebHistoryItem
+ */
+WebKitWebHistoryItem* webkit_web_history_item_new_with_data(const gchar* uri, const gchar* title)
+{
+    WebCore::KURL historyUri(uri);
+    WebCore::String historyTitle(title);
+
+    WebKitWebHistoryItem* webHistoryItem = webkit_web_history_item_new();
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+
+    priv->historyItem = new WebCore::HistoryItem(historyUri, historyTitle);
+    webkit_history_item_add(webHistoryItem, priv->historyItem);
+
+    return webHistoryItem;
+}
+
+/**
+ * webkit_web_history_item_get_title:
+ * @webHistoryItem: a #WebKitWebHistoryItem
+ *
+ * Returns the page title of @webHistoryItem
+ */
+const gchar* webkit_web_history_item_get_title(WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), NULL);
+
+    WebCore::HistoryItem* item = core(webHistoryItem);
+
+    g_return_val_if_fail(item != NULL, NULL);
+
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+    WebCore::String title = item->title();
+    g_free(priv->title);
+    priv->title = g_strdup(title.utf8().data());
+
+    return priv->title;
+}
+
+/**
+ * webkit_web_history_item_get_alternate_title:
+ * @webHistoryItem: a #WebKitWebHistoryItem
+ *
+ * Returns the alternate title of @webHistoryItem
+ *
+ * Return value: the alternate title of @webHistoryItem
+ */
+const gchar* webkit_web_history_item_get_alternate_title(WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), NULL);
+
+    WebCore::HistoryItem* item = core(webHistoryItem);
+
+    g_return_val_if_fail(item != NULL, NULL);
+
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+    WebCore::String alternateTitle = item->alternateTitle();
+    g_free(priv->alternateTitle);
+    priv->alternateTitle = g_strdup(alternateTitle.utf8().data());
+
+    return priv->alternateTitle;
+}
+
+/**
+ * webkit_web_history_item_set_alternate_title:
+ * @webHistoryItem: a #WebKitWebHistoryItem
+ * @title: the alternate title for @this history item
+ *
+ * Sets an alternate title for @webHistoryItem
+ */
+void webkit_web_history_item_set_alternate_title(WebKitWebHistoryItem* webHistoryItem, const gchar* title)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem));
+
+    WebCore::HistoryItem* item = core(webHistoryItem);
+
+    item->setAlternateTitle(WebCore::String::fromUTF8(title));
+}
+
+/**
+ * webkit_web_history_item_get_uri:
+ * @webHistoryItem: a #WebKitWebHistoryItem
+ *
+ * Returns the URI of @this
+ *
+ * Return value: the URI of @webHistoryItem
+ */
+const gchar* webkit_web_history_item_get_uri(WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), NULL);
+
+    WebCore::HistoryItem* item = core(WEBKIT_WEB_HISTORY_ITEM(webHistoryItem));
+
+    g_return_val_if_fail(item != NULL, NULL);
+
+    WebCore::String uri = item->urlString();
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+    g_free(priv->uri);
+    priv->uri = g_strdup(uri.utf8().data());
+
+    return priv->uri;
+}
+
+/**
+ * webkit_web_history_item_get_original_uri:
+ * @webHistoryItem: a #WebKitWebHistoryItem
+ *
+ * Returns the original URI of @webHistoryItem.
+ *
+ * Return value: the original URI of @webHistoryITem
+ */
+const gchar* webkit_web_history_item_get_original_uri(WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), NULL);
+
+    WebCore::HistoryItem* item = core(WEBKIT_WEB_HISTORY_ITEM(webHistoryItem));
+
+    g_return_val_if_fail(item != NULL, NULL);
+
+    WebCore::String originalUri = item->originalURLString();
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+    g_free(priv->originalUri);
+    priv->originalUri = g_strdup(originalUri.utf8().data());
+
+    return webHistoryItem->priv->originalUri;
+}
+
+/**
+ * webkit_web_history_item_get_last_visisted_time :
+ * @webHistoryItem: a #WebKitWebHistoryItem
+ *
+ * Returns the last time @webHistoryItem was visited
+ *
+ * Return value: the time in seconds this @webHistoryItem was last visited
+ */
+gdouble webkit_web_history_item_get_last_visited_time(WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), 0);
+
+    WebCore::HistoryItem* item = core(WEBKIT_WEB_HISTORY_ITEM(webHistoryItem));
+
+    g_return_val_if_fail(item != NULL, 0);
+
+    return item->lastVisitedTime();
+}
+
+} /* end extern "C" */
+
+WebCore::HistoryItem* WebKit::core(WebKitWebHistoryItem* webHistoryItem)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(webHistoryItem), NULL);
+
+    WebKitWebHistoryItemPrivate* priv = webHistoryItem->priv;
+    WebCore::HistoryItem* historyItem = priv->historyItem;
+
+    return historyItem ? historyItem : 0;
+}
+
+WebKitWebHistoryItem* WebKit::kit(WebCore::HistoryItem* historyItem)
+{
+    g_return_val_if_fail(historyItem != NULL, NULL);
+
+    WebKitWebHistoryItem* webHistoryItem;
+    GHashTable* table = webkit_history_items();
+
+    webHistoryItem = (WebKitWebHistoryItem*) g_hash_table_lookup(table, historyItem);
+    return webHistoryItem;
+}
+
diff --git a/WebKit/gtk/webkit/webkitwebhistoryitem.h b/WebKit/gtk/webkit/webkitwebhistoryitem.h
new file mode 100644
index 0000000..267ffb5
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebhistoryitem.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2008 Jan Michael C. Alonzo
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_WEB_HISTORY_ITEM_H
+#define WEBKIT_WEB_HISTORY_ITEM_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gdk/gdk.h>
+
+#include <webkit/webkitdefines.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_WEB_HISTORY_ITEM            (webkit_web_history_item_get_type())
+#define WEBKIT_WEB_HISTORY_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_WEB_HISTORY_ITEM, WebKitWebHistoryItem))
+#define WEBKIT_WEB_HISTORY_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_WEB_HISTORY_ITEM, WebKitWebHistoryItemClass))
+#define WEBKIT_IS_WEB_HISTORY_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_WEB_HISTORY_ITEM))
+#define WEBKIT_IS_WEB_HISTORY_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_WEB_HISTORY_ITEM))
+#define WEBKIT_WEB_HISTORY_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_WEB_HISTORY_ITEM, WebKitWebHistoryItemClass))
+
+typedef struct _WebKitWebHistoryItemPrivate WebKitWebHistoryItemPrivate;
+
+struct _WebKitWebHistoryItem {
+    GObject parent_instance;
+
+    WebKitWebHistoryItemPrivate* priv;
+};
+
+struct _WebKitWebHistoryItemClass {
+    GObjectClass parent_class;
+};
+
+WEBKIT_API GType
+webkit_web_history_item_get_type (void);
+
+WEBKIT_API WebKitWebHistoryItem*
+webkit_web_history_item_new (void);
+
+WEBKIT_API WebKitWebHistoryItem*
+webkit_web_history_item_new_with_data (const gchar* uri, const gchar* title);
+
+WEBKIT_API const gchar*
+webkit_web_history_item_get_title (WebKitWebHistoryItem* web_history_item);
+
+WEBKIT_API const gchar*
+webkit_web_history_item_get_alternate_title (WebKitWebHistoryItem* web_history_item);
+
+WEBKIT_API void
+webkit_web_history_item_set_alternate_title (WebKitWebHistoryItem* web_history_item, const gchar* title);
+
+WEBKIT_API const gchar*
+webkit_web_history_item_get_uri (WebKitWebHistoryItem* web_history_item);
+
+WEBKIT_API const gchar*
+webkit_web_history_item_get_original_uri (WebKitWebHistoryItem* web_history_item);
+
+WEBKIT_API gdouble
+webkit_web_history_item_get_last_visited_time (WebKitWebHistoryItem* web_history_item);
+
+G_END_DECLS
+
+#endif /* WEBKIT_WEB_HISTORY_ITEM_H */
diff --git a/WebKit/gtk/webkit/webkitwebsettings.cpp b/WebKit/gtk/webkit/webkitwebsettings.cpp
new file mode 100644
index 0000000..43b2209
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebsettings.cpp
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2008 Christian Dywan <christian@imendio.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include "webkitwebsettings.h"
+#include "webkitprivate.h"
+
+extern "C" {
+
+G_DEFINE_TYPE(WebKitWebSettings, webkit_web_settings, G_TYPE_OBJECT)
+
+struct _WebKitWebSettingsPrivate {
+    gchar* default_encoding;
+    gchar* cursive_font_family;
+    gchar* default_font_family;
+    gchar* fantasy_font_family;
+    gchar* monospace_font_family;
+    gchar* sans_serif_font_family;
+    gchar* serif_font_family;
+    guint default_font_size;
+    guint default_monospace_font_size;
+    guint minimum_font_size;
+    guint minimum_logical_font_size;
+    gboolean auto_load_images;
+    gboolean auto_shrink_images;
+    gboolean print_backgrounds;
+    gboolean enable_scripts;
+    gboolean enable_plugins;
+    gboolean resizable_text_areas;
+    gchar* user_stylesheet_uri;
+};
+
+#define WEBKIT_WEB_SETTINGS_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_SETTINGS, WebKitWebSettingsPrivate))
+
+enum {
+    PROP_0,
+
+    PROP_DEFAULT_ENCODING,
+    PROP_CURSIVE_FONT_FAMILY,
+    PROP_DEFAULT_FONT_FAMILY,
+    PROP_FANTASY_FONT_FAMILY,
+    PROP_MONOSPACE_FONT_FAMILY,
+    PROP_SANS_SERIF_FONT_FAMILY,
+    PROP_SERIF_FONT_FAMILY,
+    PROP_DEFAULT_FONT_SIZE,
+    PROP_DEFAULT_MONOSPACE_FONT_SIZE,
+    PROP_MINIMUM_FONT_SIZE,
+    PROP_MINIMUM_LOGICAL_FONT_SIZE,
+    PROP_AUTO_LOAD_IMAGES,
+    PROP_AUTO_SHRINK_IMAGES,
+    PROP_PRINT_BACKGROUNDS,
+    PROP_ENABLE_SCRIPTS,
+    PROP_ENABLE_PLUGINS,
+    PROP_RESIZABLE_TEXT_AREAS,
+    PROP_USER_STYLESHEET_URI
+};
+
+static void webkit_web_settings_finalize(GObject* object);
+
+static void webkit_web_settings_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec);
+
+static void webkit_web_settings_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec);
+
+static void webkit_web_settings_class_init(WebKitWebSettingsClass* klass)
+{
+    GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
+    gobject_class->finalize = webkit_web_settings_finalize;
+    gobject_class->set_property = webkit_web_settings_set_property;
+    gobject_class->get_property = webkit_web_settings_get_property;
+
+    GParamFlags flags = (GParamFlags)(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_DEFAULT_ENCODING,
+                                    g_param_spec_string(
+                                    "default-encoding",
+                                    "Default Encoding",
+                                    "The default encoding used to display text.",
+                                    "iso-8859-1",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_CURSIVE_FONT_FAMILY,
+                                    g_param_spec_string(
+                                    "cursive-font-family",
+                                    "Cursive Font Family",
+                                    "The default Cursive font family used to display text.",
+                                    "serif",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_DEFAULT_FONT_FAMILY,
+                                    g_param_spec_string(
+                                    "default-font-family",
+                                    "Default Font Family",
+                                    "The default font family used to display text.",
+                                    "sans-serif",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_FANTASY_FONT_FAMILY,
+                                    g_param_spec_string(
+                                    "fantasy-font-family",
+                                    "Fantasy Font Family",
+                                    "The default Fantasy font family used to display text.",
+                                    "serif",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_MONOSPACE_FONT_FAMILY,
+                                    g_param_spec_string(
+                                    "monospace-font-family",
+                                    "Monospace Font Family",
+                                    "The default font family used to display monospace text.",
+                                    "monospace",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_SANS_SERIF_FONT_FAMILY,
+                                    g_param_spec_string(
+                                    "sans-serif-font-family",
+                                    "Sans Serif Font Family",
+                                    "The default Sans Serif font family used to display text.",
+                                    "sans-serif",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_SERIF_FONT_FAMILY,
+                                    g_param_spec_string(
+                                    "serif-font-family",
+                                    "Serif Font Family",
+                                    "The default Serif font family used to display text.",
+                                    "serif",
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_DEFAULT_FONT_SIZE,
+                                    g_param_spec_int(
+                                    "default-font-size",
+                                    "Default Font Size",
+                                    "The default font size used to display text.",
+                                    5, G_MAXINT, 10,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_DEFAULT_MONOSPACE_FONT_SIZE,
+                                    g_param_spec_int(
+                                    "default-monospace-font-size",
+                                    "Default Monospace Font Size",
+                                    "The default font size used to display monospace text.",
+                                    5, G_MAXINT, 10,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_MINIMUM_FONT_SIZE,
+                                    g_param_spec_int(
+                                    "minimum-font-size",
+                                    "Minimum Font Size",
+                                    "The minimum font size used to display text.",
+                                    1, G_MAXINT, 5,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_MINIMUM_LOGICAL_FONT_SIZE,
+                                    g_param_spec_int(
+                                    "minimum-logical-font-size",
+                                    "Minimum Logical Font Size",
+                                    "The minimum logical font size used to display text.",
+                                    1, G_MAXINT, 5,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_AUTO_LOAD_IMAGES,
+                                    g_param_spec_boolean(
+                                    "auto-load-images",
+                                    "Auto Load Images",
+                                    "Load images automatically.",
+                                    TRUE,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_AUTO_SHRINK_IMAGES,
+                                    g_param_spec_boolean(
+                                    "auto-shrink-images",
+                                    "Auto Shrink Images",
+                                    "Automatically shrink standalone images to fit.",
+                                    TRUE,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_PRINT_BACKGROUNDS,
+                                    g_param_spec_boolean(
+                                    "print-backgrounds",
+                                    "Print Backgrounds",
+                                    "Whether background images should be printed.",
+                                    TRUE,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_ENABLE_SCRIPTS,
+                                    g_param_spec_boolean(
+                                    "enable-scripts",
+                                    "Enable Scripts",
+                                    "Enable embedded scripting languages.",
+                                    TRUE,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_ENABLE_PLUGINS,
+                                    g_param_spec_boolean(
+                                    "enable-plugins",
+                                    "Enable Plugins",
+                                    "Enable embedded plugin objects.",
+                                    TRUE,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_RESIZABLE_TEXT_AREAS,
+                                    g_param_spec_boolean(
+                                    "resizable-text-areas",
+                                    "Resizable Text Areas",
+                                    "Whether text areas are resizable.",
+                                    TRUE,
+                                    flags));
+
+    g_object_class_install_property(gobject_class,
+                                    PROP_USER_STYLESHEET_URI,
+                                    g_param_spec_string("user-stylesheet-uri",
+                                    "User Stylesheet URI",
+                                    "The URI of a stylesheet that is applied to every page.",
+                                    0,
+                                    flags));
+
+    g_type_class_add_private(klass, sizeof(WebKitWebSettingsPrivate));
+}
+
+static void webkit_web_settings_init(WebKitWebSettings* web_settings)
+{
+    web_settings->priv = WEBKIT_WEB_SETTINGS_GET_PRIVATE(web_settings);
+}
+
+static void webkit_web_settings_finalize(GObject* object)
+{
+    WebKitWebSettings* web_settings = WEBKIT_WEB_SETTINGS(object);
+    WebKitWebSettingsPrivate* priv = web_settings->priv;
+
+    g_free(priv->default_encoding);
+    g_free(priv->cursive_font_family);
+    g_free(priv->default_font_family);
+    g_free(priv->fantasy_font_family);
+    g_free(priv->monospace_font_family);
+    g_free(priv->sans_serif_font_family);
+    g_free(priv->serif_font_family);
+    g_free(priv->user_stylesheet_uri);
+
+    G_OBJECT_CLASS(webkit_web_settings_parent_class)->finalize(object);
+}
+
+static void webkit_web_settings_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
+{
+    WebKitWebSettings* web_settings = WEBKIT_WEB_SETTINGS(object);
+    WebKitWebSettingsPrivate* priv = web_settings->priv;
+
+    switch(prop_id) {
+    case PROP_DEFAULT_ENCODING:
+        g_free(priv->default_encoding);
+        priv->default_encoding = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_CURSIVE_FONT_FAMILY:
+        g_free(priv->cursive_font_family);
+        priv->cursive_font_family = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_DEFAULT_FONT_FAMILY:
+        g_free(priv->default_font_family);
+        priv->default_font_family = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_FANTASY_FONT_FAMILY:
+        g_free(priv->fantasy_font_family);
+        priv->fantasy_font_family = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_MONOSPACE_FONT_FAMILY:
+        g_free(priv->monospace_font_family);
+        priv->monospace_font_family = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_SANS_SERIF_FONT_FAMILY:
+        g_free(priv->sans_serif_font_family);
+        priv->sans_serif_font_family = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_SERIF_FONT_FAMILY:
+        g_free(priv->serif_font_family);
+        priv->serif_font_family = g_strdup(g_value_get_string(value));
+        break;
+    case PROP_DEFAULT_FONT_SIZE:
+        priv->default_font_size = g_value_get_int(value);
+        break;
+    case PROP_DEFAULT_MONOSPACE_FONT_SIZE:
+        priv->default_monospace_font_size = g_value_get_int(value);
+        break;
+    case PROP_MINIMUM_FONT_SIZE:
+        priv->minimum_font_size = g_value_get_int(value);
+        break;
+    case PROP_MINIMUM_LOGICAL_FONT_SIZE:
+        priv->minimum_logical_font_size = g_value_get_int(value);
+        break;
+    case PROP_AUTO_LOAD_IMAGES:
+        priv->auto_load_images = g_value_get_boolean(value);
+        break;
+    case PROP_AUTO_SHRINK_IMAGES:
+        priv->auto_shrink_images = g_value_get_boolean(value);
+        break;
+    case PROP_PRINT_BACKGROUNDS:
+        priv->print_backgrounds = g_value_get_boolean(value);
+        break;
+    case PROP_ENABLE_SCRIPTS:
+        priv->enable_scripts = g_value_get_boolean(value);
+        break;
+    case PROP_ENABLE_PLUGINS:
+        priv->enable_plugins = g_value_get_boolean(value);
+        break;
+    case PROP_RESIZABLE_TEXT_AREAS:
+        priv->resizable_text_areas = g_value_get_boolean(value);
+        break;
+    case PROP_USER_STYLESHEET_URI:
+        g_free(priv->user_stylesheet_uri);
+        priv->user_stylesheet_uri = g_strdup(g_value_get_string(value));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
+}
+
+static void webkit_web_settings_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
+{
+    WebKitWebSettings* web_settings = WEBKIT_WEB_SETTINGS(object);
+    WebKitWebSettingsPrivate* priv = web_settings->priv;
+
+    switch (prop_id) {
+    case PROP_DEFAULT_ENCODING:
+        g_value_set_string(value, priv->default_encoding);
+        break;
+    case PROP_CURSIVE_FONT_FAMILY:
+        g_value_set_string(value, priv->cursive_font_family);
+        break;
+    case PROP_DEFAULT_FONT_FAMILY:
+        g_value_set_string(value, priv->default_font_family);
+        break;
+    case PROP_FANTASY_FONT_FAMILY:
+        g_value_set_string(value, priv->fantasy_font_family);
+        break;
+    case PROP_MONOSPACE_FONT_FAMILY:
+        g_value_set_string(value, priv->monospace_font_family);
+        break;
+    case PROP_SANS_SERIF_FONT_FAMILY:
+        g_value_set_string(value, priv->sans_serif_font_family);
+        break;
+    case PROP_SERIF_FONT_FAMILY:
+        g_value_set_string(value, priv->serif_font_family);
+        break;
+    case PROP_DEFAULT_FONT_SIZE:
+        g_value_set_int(value, priv->default_font_size);
+        break;
+    case PROP_DEFAULT_MONOSPACE_FONT_SIZE:
+        g_value_set_int(value, priv->default_monospace_font_size);
+        break;
+    case PROP_MINIMUM_FONT_SIZE:
+        g_value_set_int(value, priv->minimum_font_size);
+        break;
+    case PROP_MINIMUM_LOGICAL_FONT_SIZE:
+        g_value_set_int(value, priv->minimum_logical_font_size);
+        break;
+    case PROP_AUTO_LOAD_IMAGES:
+        g_value_set_boolean(value, priv->auto_load_images);
+        break;
+    case PROP_AUTO_SHRINK_IMAGES:
+        g_value_set_boolean(value, priv->auto_shrink_images);
+        break;
+    case PROP_PRINT_BACKGROUNDS:
+        g_value_set_boolean(value, priv->print_backgrounds);
+        break;
+    case PROP_ENABLE_SCRIPTS:
+        g_value_set_boolean(value, priv->enable_scripts);
+        break;
+    case PROP_ENABLE_PLUGINS:
+        g_value_set_boolean(value, priv->enable_plugins);
+        break;
+    case PROP_RESIZABLE_TEXT_AREAS:
+        g_value_set_boolean(value, priv->resizable_text_areas);
+        break;
+    case PROP_USER_STYLESHEET_URI:
+        g_value_set_string(value, priv->user_stylesheet_uri);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
+}
+
+/**
+ * webkit_web_settings_new:
+ *
+ * Creates a new #WebKitWebSettings instance with default values. It must
+ * be manually attached to a WebView.
+ *
+ * Returns: a new #WebKitWebSettings instance
+ **/
+WebKitWebSettings* webkit_web_settings_new()
+{
+    return WEBKIT_WEB_SETTINGS(g_object_new(WEBKIT_TYPE_WEB_SETTINGS, NULL));
+}
+
+/**
+ * webkit_web_settings_copy:
+ *
+ * Copies an existing #WebKitWebSettings instance.
+ *
+ * Returns: a new #WebKitWebSettings instance
+ **/
+WebKitWebSettings* webkit_web_settings_copy(WebKitWebSettings* web_settings)
+{
+    WebKitWebSettingsPrivate* priv = web_settings->priv;
+
+    WebKitWebSettings* copy = WEBKIT_WEB_SETTINGS(g_object_new(WEBKIT_TYPE_WEB_SETTINGS,
+                 "default-encoding", priv->default_encoding,
+                 "cursive-font-family", priv->cursive_font_family,
+                 "default-font-family", priv->default_font_family,
+                 "fantasy-font-family", priv->fantasy_font_family,
+                 "monospace-font-family", priv->monospace_font_family,
+                 "sans-serif-font-family", priv->sans_serif_font_family,
+                 "serif-font-family", priv->serif_font_family,
+                 "default-font-size", priv->default_font_size,
+                 "default-monospace-font-size", priv->default_monospace_font_size,
+                 "minimum-font-size", priv->minimum_font_size,
+                 "minimum-logical-font-size", priv->minimum_logical_font_size,
+                 "auto-load-images", priv->auto_load_images,
+                 "auto-shrink-images", priv->auto_shrink_images,
+                 "print-backgrounds", priv->print_backgrounds,
+                 "enable-scripts", priv->enable_scripts,
+                 "enable-plugins", priv->enable_plugins,
+                 "resizable-text-areas", priv->resizable_text_areas,
+                 "user-stylesheet-uri", priv->user_stylesheet_uri,
+                 NULL));
+
+    return copy;
+}
+
+}
diff --git a/WebKit/gtk/webkit/webkitwebsettings.h b/WebKit/gtk/webkit/webkitwebsettings.h
new file mode 100644
index 0000000..a21ccf4
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebsettings.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2008 Christian Dywan <christian@imendio.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __WEBKIT_WEB_SETTINGS_H__
+#define __WEBKIT_WEB_SETTINGS_H__
+
+#include <glib-object.h>
+
+#include <webkit/webkitdefines.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_WEB_SETTINGS            (webkit_web_settings_get_type())
+#define WEBKIT_WEB_SETTINGS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_WEB_SETTINGS, WebKitWebSettings))
+#define WEBKIT_WEB_SETTINGS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_WEB_SETTINGS, WebKitWebSettingsClass))
+#define WEBKIT_IS_WEB_SETTINGS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_WEB_SETTINGS))
+#define WEBKIT_IS_WEB_SETTINGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_WEB_SETTINGS))
+#define WEBKIT_WEB_SETTINGS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_WEB_SETTINGS, WebKitWebSettingsClass))
+
+typedef struct _WebKitWebSettingsPrivate WebKitWebSettingsPrivate;
+
+struct _WebKitWebSettings {
+    GObject parent_instance;
+
+    WebKitWebSettingsPrivate* priv;
+};
+
+struct _WebKitWebSettingsClass {
+    GObjectClass parent_class;
+
+    /* Padding for future expansion */
+    void (*_webkit_reserved1) (void);
+    void (*_webkit_reserved2) (void);
+    void (*_webkit_reserved3) (void);
+    void (*_webkit_reserved4) (void);
+};
+
+WEBKIT_API GType
+webkit_web_settings_get_type(void);
+
+WEBKIT_API WebKitWebSettings*
+webkit_web_settings_new(void);
+
+WEBKIT_API WebKitWebSettings*
+webkit_web_settings_copy(WebKitWebSettings* web_settings);
+
+G_END_DECLS
+
+#endif /* __WEBKIT_WEB_SETTINGS_H__ */
diff --git a/WebKit/gtk/webkit/webkitwebview.cpp b/WebKit/gtk/webkit/webkitwebview.cpp
new file mode 100644
index 0000000..81b196c
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebview.cpp
@@ -0,0 +1,1938 @@
+/*
+ *  Copyright (C) 2007 Holger Hans Peter Freyther
+ *  Copyright (C) 2007, 2008 Christian Dywan <christian@imendio.com>
+ *  Copyright (C) 2007 Xan Lopez <xan@gnome.org>
+ *  Copyright (C) 2007 Alp Toker <alp@atoker.com>
+ *  Copyright (C) 2008 Jan Alonzo <jmalonzo@unpluggable.com>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "config.h"
+
+#include "webkitwebview.h"
+#include "webkit-marshal.h"
+#include "webkitprivate.h"
+#include "webkitwebbackforwardlist.h"
+#include "webkitwebhistoryitem.h"
+
+#include "NotImplemented.h"
+#include "BackForwardList.h"
+#include "CString.h"
+#include "ChromeClientGtk.h"
+#include "ContextMenu.h"
+#include "ContextMenuClientGtk.h"
+#include "ContextMenuController.h"
+#include "Cursor.h"
+#include "DragClientGtk.h"
+#include "Editor.h"
+#include "EditorClientGtk.h"
+#include "EventHandler.h"
+#include "FocusController.h"
+#include "FrameLoaderTypes.h"
+#include "HitTestRequest.h"
+#include "HitTestResult.h"
+#include "GraphicsContext.h"
+#include "InspectorClientGtk.h"
+#include "FrameLoader.h"
+#include "FrameView.h"
+#include "Editor.h"
+#include "PasteboardHelper.h"
+#include "PlatformKeyboardEvent.h"
+#include "PlatformWheelEvent.h"
+#include "SubstituteData.h"
+
+#include <gdk/gdkkeysyms.h>
+
+static const double defaultDPI = 96.0;
+
+using namespace WebKit;
+using namespace WebCore;
+
+extern "C" {
+
+enum {
+    /* normal signals */
+    NAVIGATION_REQUESTED,
+    WINDOW_OBJECT_CLEARED,
+    LOAD_STARTED,
+    LOAD_COMMITTED,
+    LOAD_PROGRESS_CHANGED,
+    LOAD_FINISHED,
+    TITLE_CHANGED,
+    HOVERING_OVER_LINK,
+    POPULATE_POPUP,
+    STATUS_BAR_TEXT_CHANGED,
+    ICOND_LOADED,
+    SELECTION_CHANGED,
+    CONSOLE_MESSAGE,
+    SCRIPT_ALERT,
+    SCRIPT_CONFIRM,
+    SCRIPT_PROMPT,
+    SELECT_ALL,
+    COPY_CLIPBOARD,
+    PASTE_CLIPBOARD,
+    CUT_CLIPBOARD,
+    LAST_SIGNAL
+};
+
+enum {
+    PROP_0,
+
+    PROP_COPY_TARGET_LIST,
+    PROP_PASTE_TARGET_LIST,
+    PROP_EDITABLE,
+    PROP_SETTINGS,
+    PROP_TRANSPARENT
+};
+
+static guint webkit_web_view_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE(WebKitWebView, webkit_web_view, GTK_TYPE_CONTAINER)
+
+static void webkit_web_view_context_menu_position_func(GtkMenu*, gint* x, gint* y, gboolean* pushIn, WebKitWebViewPrivate* data)
+{
+    *pushIn = FALSE;
+    *x = data->lastPopupXPosition;
+    *y = data->lastPopupYPosition;
+}
+
+static gboolean webkit_web_view_forward_context_menu_event(WebKitWebView* webView, const PlatformMouseEvent& event)
+{
+    Page* page = core(webView);
+    page->contextMenuController()->clearContextMenu();
+    Frame* focusedFrame = page->focusController()->focusedOrMainFrame();
+    focusedFrame->view()->setCursor(pointerCursor());
+    bool handledEvent = focusedFrame->eventHandler()->sendContextMenuEvent(event);
+    if (!handledEvent)
+        return FALSE;
+
+    ContextMenu* coreMenu = page->contextMenuController()->contextMenu();
+    if (!coreMenu)
+        return FALSE;
+
+    GtkMenu* menu = GTK_MENU(coreMenu->platformDescription());
+    if (!menu)
+        return FALSE;
+
+    g_signal_emit(webView, webkit_web_view_signals[POPULATE_POPUP], 0, menu);
+
+    GList* items = gtk_container_get_children(GTK_CONTAINER(menu));
+    bool empty = !g_list_nth(items, 0);
+    g_list_free(items);
+    if (empty)
+        return FALSE;
+
+    WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
+    priv->lastPopupXPosition = event.globalX();
+    priv->lastPopupYPosition = event.globalY();
+    gtk_menu_popup(menu, NULL, NULL,
+                   reinterpret_cast<GtkMenuPositionFunc>(webkit_web_view_context_menu_position_func),
+                   priv, event.button() + 1, gtk_get_current_event_time());
+    return TRUE;
+}
+
+static gboolean webkit_web_view_popup_menu_handler(GtkWidget* widget)
+{
+    static const int contextMenuMargin = 1;
+
+    // The context menu event was generated from the keyboard, so show the context menu by the current selection.
+    Page* page = core(WEBKIT_WEB_VIEW(widget));
+    FrameView* view = page->mainFrame()->view();
+    Position start = page->mainFrame()->selectionController()->selection().start();
+    Position end = page->mainFrame()->selectionController()->selection().end();
+
+    int rightAligned = FALSE;
+    IntPoint location;
+
+    if (!start.node() || !end.node())
+        location = IntPoint(rightAligned ? view->contentsWidth() - contextMenuMargin : contextMenuMargin, contextMenuMargin);
+    else {
+        RenderObject* renderer = start.node()->renderer();
+        if (!renderer)
+            return FALSE;
+
+        // Calculate the rect of the first line of the selection (cribbed from -[WebCoreFrameBridge firstRectForDOMRange:]).
+        int extraWidthToEndOfLine = 0;
+        IntRect startCaretRect = renderer->caretRect(start.offset(), DOWNSTREAM, &extraWidthToEndOfLine);
+        IntRect endCaretRect = renderer->caretRect(end.offset(), UPSTREAM);
+
+        IntRect firstRect;
+        if (startCaretRect.y() == endCaretRect.y())
+            firstRect = IntRect(MIN(startCaretRect.x(), endCaretRect.x()),
+                                startCaretRect.y(),
+                                abs(endCaretRect.x() - startCaretRect.x()),
+                                MAX(startCaretRect.height(), endCaretRect.height()));
+        else
+            firstRect = IntRect(startCaretRect.x(),
+                                startCaretRect.y(),
+                                startCaretRect.width() + extraWidthToEndOfLine,
+                                startCaretRect.height());
+
+        location = IntPoint(rightAligned ? firstRect.right() : firstRect.x(), firstRect.bottom());
+    }
+
+    int x, y;
+    gdk_window_get_origin(GTK_WIDGET(view->containingWindow())->window, &x, &y);
+
+    // FIXME: The IntSize(0, -1) is a hack to get the hit-testing to result in the selected element.
+    // Ideally we'd have the position of a context menu event be separate from its target node.
+    location = view->contentsToWindow(location) + IntSize(0, -1);
+    IntPoint global = location + IntSize(x, y);
+    PlatformMouseEvent event(location, global, NoButton, MouseEventPressed, 0, false, false, false, false, gtk_get_current_event_time());
+
+    return webkit_web_view_forward_context_menu_event(WEBKIT_WEB_VIEW(widget), event);
+}
+
+static void webkit_web_view_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
+
+    switch(prop_id) {
+    case PROP_COPY_TARGET_LIST:
+        g_value_set_boxed(value, webkit_web_view_get_copy_target_list(webView));
+        break;
+    case PROP_PASTE_TARGET_LIST:
+        g_value_set_boxed(value, webkit_web_view_get_paste_target_list(webView));
+        break;
+    case PROP_EDITABLE:
+        g_value_set_boolean(value, webkit_web_view_get_editable(webView));
+        break;
+    case PROP_SETTINGS:
+        g_value_set_object(value, webkit_web_view_get_settings(webView));
+        break;
+    case PROP_TRANSPARENT:
+        g_value_set_boolean(value, webkit_web_view_get_transparent(webView));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    }
+}
+
+static void webkit_web_view_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec *pspec)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
+
+    switch(prop_id) {
+    case PROP_EDITABLE:
+        webkit_web_view_set_editable(webView, g_value_get_boolean(value));
+        break;
+    case PROP_SETTINGS:
+        webkit_web_view_set_settings(webView, WEBKIT_WEB_SETTINGS(g_value_get_object(value)));
+        break;
+    case PROP_TRANSPARENT:
+        webkit_web_view_set_transparent(webView, g_value_get_boolean(value));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    }
+}
+
+static gboolean webkit_web_view_expose_event(GtkWidget* widget, GdkEventExpose* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    Frame* frame = core(webView)->mainFrame();
+    GdkRectangle clip;
+    gdk_region_get_clipbox(event->region, &clip);
+    cairo_t* cr = gdk_cairo_create(event->window);
+    GraphicsContext ctx(cr);
+    ctx.setGdkExposeEvent(event);
+    if (frame->renderer()) {
+        frame->view()->layoutIfNeededRecursive();
+
+        if (priv->transparent) {
+            cairo_save(cr);
+            cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
+            cairo_paint(cr);
+            cairo_restore(cr);
+        }
+
+        frame->view()->paint(&ctx, clip);
+    }
+    cairo_destroy(cr);
+
+    return FALSE;
+}
+
+static gboolean webkit_web_view_key_press_event(GtkWidget* widget, GdkEventKey* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    PlatformKeyboardEvent keyboardEvent(event);
+
+    if (frame->eventHandler()->keyEvent(keyboardEvent))
+        return TRUE;
+
+    FrameView* view = frame->view();
+    SelectionController::EAlteration alteration;
+    if (event->state & GDK_SHIFT_MASK)
+        alteration = SelectionController::EXTEND;
+    else
+        alteration = SelectionController::MOVE;
+
+    // TODO: We probably want to use GTK+ key bindings here and perhaps take an
+    // approach more like the Win and Mac ports for key handling.
+    switch (event->keyval) {
+    case GDK_Down:
+        view->scrollBy(0, LINE_STEP);
+        return TRUE;
+    case GDK_Up:
+        view->scrollBy(0, -LINE_STEP);
+        return TRUE;
+    case GDK_Right:
+        view->scrollBy(LINE_STEP, 0);
+        return TRUE;
+    case GDK_Left:
+        view->scrollBy(-LINE_STEP, 0);
+        return TRUE;
+    case GDK_Home:
+        frame->selectionController()->modify(alteration, SelectionController::BACKWARD, DocumentBoundary, true);
+        return TRUE;
+    case GDK_End:
+        frame->selectionController()->modify(alteration, SelectionController::FORWARD, DocumentBoundary, true);
+        return TRUE;
+    }
+
+    /* Chain up to our parent class for binding activation */
+    return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->key_press_event(widget, event);
+}
+
+static gboolean webkit_web_view_key_release_event(GtkWidget* widget, GdkEventKey* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    PlatformKeyboardEvent keyboardEvent(event);
+
+    if (frame->eventHandler()->keyEvent(keyboardEvent))
+        return TRUE;
+
+    /* Chain up to our parent class for binding activation */
+    return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->key_release_event(widget, event);
+}
+
+static gboolean webkit_web_view_button_press_event(GtkWidget* widget, GdkEventButton* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+    Frame* frame = core(webView)->mainFrame();
+
+    // FIXME: need to keep track of subframe focus for key events
+    gtk_widget_grab_focus(widget);
+
+    if (event->button == 3)
+        return webkit_web_view_forward_context_menu_event(webView, PlatformMouseEvent(event));
+
+    return frame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));
+}
+
+static gboolean webkit_web_view_button_release_event(GtkWidget* widget, GdkEventButton* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+    WebKitWebViewPrivate* priv = webView->priv;
+    Frame* focusedFrame = core(webView)->focusController()->focusedFrame();
+
+    if (focusedFrame && focusedFrame->editor()->canEdit()) {
+        GdkWindow* window = gtk_widget_get_parent_window(widget);
+        gtk_im_context_set_client_window(priv->imContext, window);
+#ifdef MAEMO_CHANGES
+        hildon_gtk_im_context_filter_event(priv->imContext, (GdkEvent*)event);
+        hildon_gtk_im_context_show(priv->imContext);
+#endif
+    }
+
+    return focusedFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));
+}
+
+static gboolean webkit_web_view_motion_event(GtkWidget* widget, GdkEventMotion* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+    Frame* frame = core(webView)->mainFrame();
+    return frame->eventHandler()->mouseMoved(PlatformMouseEvent(event));
+}
+
+static gboolean webkit_web_view_scroll_event(GtkWidget* widget, GdkEventScroll* event)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+    Frame* frame = core(webView)->mainFrame();
+    PlatformWheelEvent wheelEvent(event);
+    return frame->eventHandler()->handleWheelEvent(wheelEvent);
+}
+
+static void webkit_web_view_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
+{
+    GTK_WIDGET_CLASS(webkit_web_view_parent_class)->size_allocate(widget,allocation);
+
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+    Frame* frame = core(webView)->mainFrame();
+    frame->view()->resize(allocation->width, allocation->height);
+    frame->forceLayout();
+    frame->view()->adjustViewSize();
+}
+
+static gboolean webkit_web_view_focus_in_event(GtkWidget* widget, GdkEventFocus* event)
+{
+    // TODO: Improve focus handling as suggested in
+    // http://bugs.webkit.org/show_bug.cgi?id=16910
+    GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
+    if (GTK_WIDGET_TOPLEVEL(toplevel) && gtk_window_has_toplevel_focus(GTK_WINDOW(toplevel))) {
+        WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);
+
+        Frame* frame = core(webView)->mainFrame();
+        core(webView)->focusController()->setActive(frame);
+    }
+    return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->focus_in_event(widget, event);
+}
+
+static void webkit_web_view_realize(GtkWidget* widget)
+{
+    GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+
+    GdkWindowAttr attributes;
+    attributes.window_type = GDK_WINDOW_CHILD;
+    attributes.x = widget->allocation.x;
+    attributes.y = widget->allocation.y;
+    attributes.width = widget->allocation.width;
+    attributes.height = widget->allocation.height;
+    attributes.wclass = GDK_INPUT_OUTPUT;
+    attributes.visual = gtk_widget_get_visual (widget);
+    attributes.colormap = gtk_widget_get_colormap (widget);
+    attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK
+                            | GDK_EXPOSURE_MASK
+                            | GDK_BUTTON_PRESS_MASK
+                            | GDK_BUTTON_RELEASE_MASK
+                            | GDK_POINTER_MOTION_MASK
+                            | GDK_KEY_PRESS_MASK
+                            | GDK_KEY_RELEASE_MASK
+                            | GDK_BUTTON_MOTION_MASK
+                            | GDK_BUTTON1_MOTION_MASK
+                            | GDK_BUTTON2_MOTION_MASK
+                            | GDK_BUTTON3_MOTION_MASK;
+
+    gint attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+    widget->window = gdk_window_new(gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
+    gdk_window_set_user_data(widget->window, widget);
+
+    widget->style = gtk_style_attach(widget->style, widget->window);
+    gdk_window_set_background(widget->window, &widget->style->base[GTK_WIDGET_STATE(widget)]);
+}
+
+static void webkit_web_view_set_scroll_adjustments(WebKitWebView* webView, GtkAdjustment* hadj, GtkAdjustment* vadj)
+{
+    FrameView* view = core(webkit_web_view_get_main_frame(webView))->view();
+    view->setGtkAdjustments(hadj, vadj);
+}
+
+static void webkit_web_view_container_add(GtkContainer* container, GtkWidget* widget)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(container);
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    priv->children.add(widget);
+    if (GTK_WIDGET_REALIZED(container))
+        gtk_widget_set_parent_window(widget, GTK_WIDGET(webView)->window);
+    gtk_widget_set_parent(widget, GTK_WIDGET(container));
+}
+
+static void webkit_web_view_container_remove(GtkContainer* container, GtkWidget* widget)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(container);
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    if (priv->children.contains(widget)) {
+        gtk_widget_unparent(widget);
+        priv->children.remove(widget);
+    }
+}
+
+static void webkit_web_view_container_forall(GtkContainer* container, gboolean, GtkCallback callback, gpointer callbackData)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(container);
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    HashSet<GtkWidget*> children = priv->children;
+    HashSet<GtkWidget*>::const_iterator end = children.end();
+    for (HashSet<GtkWidget*>::const_iterator current = children.begin(); current != end; ++current)
+        (*callback)(*current, callbackData);
+}
+
+static WebKitWebView* webkit_web_view_real_create_web_view(WebKitWebView*)
+{
+    notImplemented();
+    return 0;
+}
+
+static WebKitNavigationResponse webkit_web_view_real_navigation_requested(WebKitWebView*, WebKitWebFrame* frame, WebKitNetworkRequest*)
+{
+    notImplemented();
+    return WEBKIT_NAVIGATION_RESPONSE_ACCEPT;
+}
+
+static void webkit_web_view_real_window_object_cleared(WebKitWebView*, WebKitWebFrame*, JSGlobalContextRef context, JSObjectRef window_object)
+{
+    notImplemented();
+}
+
+static gchar* webkit_web_view_real_choose_file(WebKitWebView*, WebKitWebFrame*, const gchar* old_name)
+{
+    notImplemented();
+    return g_strdup(old_name);
+}
+
+typedef enum {
+    WEBKIT_SCRIPT_DIALOG_ALERT,
+    WEBKIT_SCRIPT_DIALOG_CONFIRM,
+    WEBKIT_SCRIPT_DIALOG_PROMPT
+ } WebKitScriptDialogType;
+
+static gboolean webkit_web_view_script_dialog(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, WebKitScriptDialogType type, const gchar* defaultValue, gchar** value)
+{
+    GtkMessageType messageType;
+    GtkButtonsType buttons;
+    gint defaultResponse;
+    GtkWidget* window;
+    GtkWidget* dialog;
+    GtkWidget* entry = 0;
+    gboolean didConfirm = FALSE;
+
+    switch (type) {
+    case WEBKIT_SCRIPT_DIALOG_ALERT:
+        messageType = GTK_MESSAGE_WARNING;
+        buttons = GTK_BUTTONS_CLOSE;
+        defaultResponse = GTK_RESPONSE_CLOSE;
+        break;
+    case WEBKIT_SCRIPT_DIALOG_CONFIRM:
+        messageType = GTK_MESSAGE_QUESTION;
+        buttons = GTK_BUTTONS_YES_NO;
+        defaultResponse = GTK_RESPONSE_YES;
+        break;
+    case WEBKIT_SCRIPT_DIALOG_PROMPT:
+        messageType = GTK_MESSAGE_QUESTION;
+        buttons = GTK_BUTTONS_OK_CANCEL;
+        defaultResponse = GTK_RESPONSE_OK;
+        break;
+    default:
+        g_warning("Unknown value for WebKitScriptDialogType.");
+        return FALSE;
+    }
+
+    window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
+    dialog = gtk_message_dialog_new(GTK_WIDGET_TOPLEVEL(window) ? GTK_WINDOW(window) : 0, GTK_DIALOG_DESTROY_WITH_PARENT, messageType, buttons, "%s", message);
+    gchar* title = g_strconcat("JavaScript - ", webkit_web_frame_get_uri(frame), NULL);
+    gtk_window_set_title(GTK_WINDOW(dialog), title);
+    g_free(title);
+
+    if (type == WEBKIT_SCRIPT_DIALOG_PROMPT) {
+        entry = gtk_entry_new();
+        gtk_entry_set_text(GTK_ENTRY(entry), defaultValue);
+        gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), entry);
+        gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
+        gtk_widget_show(entry);
+    }
+
+    gtk_dialog_set_default_response(GTK_DIALOG(dialog), defaultResponse);
+    gint response = gtk_dialog_run(GTK_DIALOG(dialog));
+
+    switch (response) {
+    case GTK_RESPONSE_YES:
+        didConfirm = TRUE;
+        break;
+    case GTK_RESPONSE_OK:
+        didConfirm = TRUE;
+        if (entry)
+            *value = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
+        else
+            *value = 0;
+        break;
+    case GTK_RESPONSE_NO:
+    case GTK_RESPONSE_CANCEL:
+        didConfirm = FALSE;
+        break;
+
+    }
+    gtk_widget_destroy(GTK_WIDGET(dialog));
+    return didConfirm;
+}
+
+static gboolean webkit_web_view_real_script_alert(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message)
+{
+    webkit_web_view_script_dialog(webView, frame, message, WEBKIT_SCRIPT_DIALOG_ALERT, 0, 0);
+    return TRUE;
+}
+
+static gboolean webkit_web_view_real_script_confirm(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, gboolean* didConfirm)
+{
+    *didConfirm = webkit_web_view_script_dialog(webView, frame, message, WEBKIT_SCRIPT_DIALOG_CONFIRM, 0, 0);
+    return TRUE;
+}
+
+static gboolean webkit_web_view_real_script_prompt(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, const gchar* defaultValue, gchar** value)
+{
+    if (!webkit_web_view_script_dialog(webView, frame, message, WEBKIT_SCRIPT_DIALOG_PROMPT, defaultValue, value))
+        *value = NULL;
+    return TRUE;
+}
+
+static gboolean webkit_web_view_real_console_message(WebKitWebView* webView, const gchar* message, unsigned int line, const gchar* sourceId)
+{
+    g_print("console message: %s @%d: %s\n", sourceId, line, message);
+    return TRUE;
+}
+
+static void webkit_web_view_real_select_all(WebKitWebView* webView)
+{
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    frame->editor()->command("SelectAll").execute();
+}
+
+static void webkit_web_view_real_cut_clipboard(WebKitWebView* webView)
+{
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    frame->editor()->command("Cut").execute();
+}
+
+static void webkit_web_view_real_copy_clipboard(WebKitWebView* webView)
+{
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    frame->editor()->command("Copy").execute();
+}
+
+static void webkit_web_view_real_paste_clipboard(WebKitWebView* webView)
+{
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    frame->editor()->command("Paste").execute();
+}
+
+static void webkit_web_view_finalize(GObject* object)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    webkit_web_view_stop_loading(WEBKIT_WEB_VIEW(object));
+
+    core(priv->mainFrame)->loader()->detachChildren();
+    delete priv->corePage;
+
+    g_object_unref(priv->backForwardList);
+    g_object_unref(priv->webSettings);
+    g_object_unref(priv->mainFrame);
+    g_object_unref(priv->imContext);
+    gtk_target_list_unref(priv->copy_target_list);
+    gtk_target_list_unref(priv->paste_target_list);
+    delete priv->userAgent;
+
+    G_OBJECT_CLASS(webkit_web_view_parent_class)->finalize(object);
+}
+
+static gboolean webkit_navigation_request_handled(GSignalInvocationHint* ihint, GValue* returnAccu, const GValue* handlerReturn, gpointer dummy)
+{
+  gboolean continueEmission = TRUE;
+  int signalHandled = g_value_get_int(handlerReturn);
+  g_value_set_int(returnAccu, signalHandled);
+
+  if (signalHandled != WEBKIT_NAVIGATION_RESPONSE_ACCEPT)
+      continueEmission = FALSE;
+
+  return continueEmission;
+}
+
+static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
+{
+    GtkBindingSet* binding_set;
+
+    webkit_init();
+
+    /*
+     * Signals
+     */
+
+    webkit_web_view_signals[NAVIGATION_REQUESTED] = g_signal_new("navigation-requested",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET (WebKitWebViewClass, navigation_requested),
+            webkit_navigation_request_handled,
+            NULL,
+            webkit_marshal_INT__OBJECT_OBJECT,
+            G_TYPE_INT, 2,
+            G_TYPE_OBJECT,
+            G_TYPE_OBJECT);
+
+    /**
+     * WebKitWebView::window-object-cleared:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the #WebKitWebFrame to which @window_object belongs
+     * @context: the #JSGlobalContextRef holding the global object and other
+     * execution state; equivalent to the return value of
+     * webkit_web_frame_get_global_context(@frame)
+     *
+     * @window_object: the #JSObjectRef representing the frame's JavaScript
+     * window object
+     *
+     * Emitted when the JavaScript window object in a #WebKitWebFrame has been
+     * cleared in preparation for a new load. This is the preferred place to
+     * set custom properties on the window object using the JavaScriptCore API.
+     */
+    webkit_web_view_signals[WINDOW_OBJECT_CLEARED] = g_signal_new("window-object-cleared",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET (WebKitWebViewClass, window_object_cleared),
+            NULL,
+            NULL,
+            webkit_marshal_VOID__OBJECT_POINTER_POINTER,
+            G_TYPE_NONE, 3,
+            WEBKIT_TYPE_WEB_FRAME,
+            G_TYPE_POINTER,
+            G_TYPE_POINTER);
+
+    /**
+     * WebKitWebView::load-started:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the frame going to do the load
+     *
+     * When a #WebKitWebFrame begins to load this signal is emitted.
+     */
+    webkit_web_view_signals[LOAD_STARTED] = g_signal_new("load-started",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__OBJECT,
+            G_TYPE_NONE, 1,
+            WEBKIT_TYPE_WEB_FRAME);
+
+    /**
+     * WebKitWebView::load-committed:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the main frame that received the first data
+     *
+     * When a #WebKitWebFrame loaded the first data this signal is emitted.
+     */
+    webkit_web_view_signals[LOAD_COMMITTED] = g_signal_new("load-committed",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__OBJECT,
+            G_TYPE_NONE, 1,
+            WEBKIT_TYPE_WEB_FRAME);
+
+
+    /**
+     * WebKitWebView::load-progress-changed:
+     * @web_view: the #WebKitWebView
+     * @progress: the global progress
+     */
+    webkit_web_view_signals[LOAD_PROGRESS_CHANGED] = g_signal_new("load-progress-changed",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__INT,
+            G_TYPE_NONE, 1,
+            G_TYPE_INT);
+
+    webkit_web_view_signals[LOAD_FINISHED] = g_signal_new("load-finished",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__OBJECT,
+            G_TYPE_NONE, 1,
+            WEBKIT_TYPE_WEB_FRAME);
+
+    /**
+     * WebKitWebView::title-changed:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the main frame
+     * @title: the new title
+     *
+     * When a #WebKitWebFrame changes the document title this signal is emitted.
+     */
+    webkit_web_view_signals[TITLE_CHANGED] = g_signal_new("title-changed",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            webkit_marshal_VOID__OBJECT_STRING,
+            G_TYPE_NONE, 2,
+            WEBKIT_TYPE_WEB_FRAME,
+            G_TYPE_STRING);
+
+    webkit_web_view_signals[HOVERING_OVER_LINK] = g_signal_new("hovering-over-link",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            webkit_marshal_VOID__STRING_STRING,
+            G_TYPE_NONE, 2,
+            G_TYPE_STRING,
+            G_TYPE_STRING);
+
+    /**
+     * WebKitWebView::populate-popup:
+     * @web_view: the object on which the signal is emitted
+     * @menu: the context menu
+     *
+     * When a context menu is about to be displayed this signal is emitted.
+     *
+     * Add menu items to #menu to extend the context menu.
+     */
+    webkit_web_view_signals[POPULATE_POPUP] = g_signal_new("populate-popup",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__OBJECT,
+            G_TYPE_NONE, 1,
+            GTK_TYPE_MENU);
+
+    webkit_web_view_signals[STATUS_BAR_TEXT_CHANGED] = g_signal_new("status-bar-text-changed",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__STRING,
+            G_TYPE_NONE, 1,
+            G_TYPE_STRING);
+
+    webkit_web_view_signals[ICOND_LOADED] = g_signal_new("icon-loaded",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    webkit_web_view_signals[SELECTION_CHANGED] = g_signal_new("selection-changed",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            0,
+            NULL,
+            NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    /**
+     * WebKitWebView::console-message:
+     * @web_view: the object on which the signal is emitted
+     * @message: the message text
+     * @line: the line where the error occured
+     * @source_id: the source id
+     * @return: TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
+     *
+     * A JavaScript console message was created.
+     */
+    webkit_web_view_signals[CONSOLE_MESSAGE] = g_signal_new("console-message",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, console_message),
+            g_signal_accumulator_true_handled,
+            NULL,
+            webkit_marshal_BOOLEAN__STRING_INT_STRING,
+            G_TYPE_BOOLEAN, 3,
+            G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
+
+    /**
+     * WebKitWebView::script-alert:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the relevant frame
+     * @message: the message text
+     * @return: TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
+     *
+     * A JavaScript alert dialog was created.
+     */
+    webkit_web_view_signals[SCRIPT_ALERT] = g_signal_new("script-alert",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, script_alert),
+            g_signal_accumulator_true_handled,
+            NULL,
+            webkit_marshal_BOOLEAN__OBJECT_STRING,
+            G_TYPE_BOOLEAN, 2,
+            G_TYPE_OBJECT, G_TYPE_STRING);
+
+    /**
+     * WebKitWebView::script-confirm:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the relevant frame
+     * @message: the message text
+     * @confirmed: whether the dialog has been confirmed
+     * @return: TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
+     *
+     * A JavaScript confirm dialog was created, providing Yes and No buttons.
+     */
+    webkit_web_view_signals[SCRIPT_CONFIRM] = g_signal_new("script-confirm",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, script_confirm),
+            g_signal_accumulator_true_handled,
+            NULL,
+            webkit_marshal_BOOLEAN__OBJECT_STRING_BOOLEAN,
+            G_TYPE_BOOLEAN, 3,
+            G_TYPE_OBJECT, G_TYPE_STRING, G_TYPE_BOOLEAN);
+
+    /**
+     * WebKitWebView::script-prompt:
+     * @web_view: the object on which the signal is emitted
+     * @frame: the relevant frame
+     * @message: the message text
+     * @default: the default value
+     * @text: To be filled with the return value or NULL if the dialog was cancelled.
+     * @return: TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
+     *
+     * A JavaScript prompt dialog was created, providing an entry to input text.
+     */
+    webkit_web_view_signals[SCRIPT_PROMPT] = g_signal_new("script-prompt",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, script_prompt),
+            g_signal_accumulator_true_handled,
+            NULL,
+            webkit_marshal_BOOLEAN__OBJECT_STRING_STRING_STRING,
+            G_TYPE_BOOLEAN, 4,
+            G_TYPE_OBJECT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
+
+    /**
+     * WebKitWebView::select-all:
+     * @web_view: the object which received the signal
+     *
+     * The ::select-all signal is a keybinding signal which gets emitted to
+     * select the complete contents of the text view.
+     *
+     * The default bindings for this signal is Ctrl-a.
+     */
+    webkit_web_view_signals[SELECT_ALL] = g_signal_new("select-all",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, select_all),
+            NULL, NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    /**
+     * WebKitWebView::cut-clipboard:
+     * @web_view: the object which received the signal
+     *
+     * The ::cut-clipboard signal is a keybinding signal which gets emitted to
+     * cut the selection to the clipboard.
+     *
+     * The default bindings for this signal are Ctrl-x and Shift-Delete.
+     */
+    webkit_web_view_signals[CUT_CLIPBOARD] = g_signal_new("cut-clipboard",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, cut_clipboard),
+            NULL, NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    /**
+     * WebKitWebView::copy-clipboard:
+     * @web_view: the object which received the signal
+     *
+     * The ::copy-clipboard signal is a keybinding signal which gets emitted to
+     * copy the selection to the clipboard.
+     *
+     * The default bindings for this signal are Ctrl-c and Ctrl-Insert.
+     */
+    webkit_web_view_signals[COPY_CLIPBOARD] = g_signal_new("copy-clipboard",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, copy_clipboard),
+            NULL, NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    /**
+     * WebKitWebView::paste-clipboard:
+     * @web_view: the object which received the signal
+     *
+     * The ::paste-clipboard signal is a keybinding signal which gets emitted to
+     * paste the contents of the clipboard into the Web view.
+     *
+     * The default bindings for this signal are Ctrl-v and Shift-Insert.
+     */
+    webkit_web_view_signals[PASTE_CLIPBOARD] = g_signal_new("paste-clipboard",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, paste_clipboard),
+            NULL, NULL,
+            g_cclosure_marshal_VOID__VOID,
+            G_TYPE_NONE, 0);
+
+    /*
+     * implementations of virtual methods
+     */
+    webViewClass->create_web_view = webkit_web_view_real_create_web_view;
+    webViewClass->navigation_requested = webkit_web_view_real_navigation_requested;
+    webViewClass->window_object_cleared = webkit_web_view_real_window_object_cleared;
+    webViewClass->choose_file = webkit_web_view_real_choose_file;
+    webViewClass->script_alert = webkit_web_view_real_script_alert;
+    webViewClass->script_confirm = webkit_web_view_real_script_confirm;
+    webViewClass->script_prompt = webkit_web_view_real_script_prompt;
+    webViewClass->console_message = webkit_web_view_real_console_message;
+    webViewClass->select_all = webkit_web_view_real_select_all;
+    webViewClass->cut_clipboard = webkit_web_view_real_cut_clipboard;
+    webViewClass->copy_clipboard = webkit_web_view_real_copy_clipboard;
+    webViewClass->paste_clipboard = webkit_web_view_real_paste_clipboard;
+
+    GObjectClass* objectClass = G_OBJECT_CLASS(webViewClass);
+    objectClass->finalize = webkit_web_view_finalize;
+    objectClass->get_property = webkit_web_view_get_property;
+    objectClass->set_property = webkit_web_view_set_property;
+
+    GtkWidgetClass* widgetClass = GTK_WIDGET_CLASS(webViewClass);
+    widgetClass->realize = webkit_web_view_realize;
+    widgetClass->expose_event = webkit_web_view_expose_event;
+    widgetClass->key_press_event = webkit_web_view_key_press_event;
+    widgetClass->key_release_event = webkit_web_view_key_release_event;
+    widgetClass->button_press_event = webkit_web_view_button_press_event;
+    widgetClass->button_release_event = webkit_web_view_button_release_event;
+    widgetClass->motion_notify_event = webkit_web_view_motion_event;
+    widgetClass->scroll_event = webkit_web_view_scroll_event;
+    widgetClass->size_allocate = webkit_web_view_size_allocate;
+    widgetClass->popup_menu = webkit_web_view_popup_menu_handler;
+    widgetClass->focus_in_event = webkit_web_view_focus_in_event;
+
+    GtkContainerClass* containerClass = GTK_CONTAINER_CLASS(webViewClass);
+    containerClass->add = webkit_web_view_container_add;
+    containerClass->remove = webkit_web_view_container_remove;
+    containerClass->forall = webkit_web_view_container_forall;
+
+    /*
+     * make us scrollable (e.g. addable to a GtkScrolledWindow)
+     */
+    webViewClass->set_scroll_adjustments = webkit_web_view_set_scroll_adjustments;
+    GTK_WIDGET_CLASS(webViewClass)->set_scroll_adjustments_signal = g_signal_new("set-scroll-adjustments",
+            G_TYPE_FROM_CLASS(webViewClass),
+            (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
+            G_STRUCT_OFFSET(WebKitWebViewClass, set_scroll_adjustments),
+            NULL, NULL,
+            webkit_marshal_VOID__OBJECT_OBJECT,
+            G_TYPE_NONE, 2,
+            GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
+
+    /*
+     * Key bindings
+     */
+
+    binding_set = gtk_binding_set_by_class(webViewClass);
+
+    gtk_binding_entry_add_signal(binding_set, GDK_a, GDK_CONTROL_MASK,
+                                 "select_all", 0);
+
+    /* Cut/copy/paste */
+
+    gtk_binding_entry_add_signal(binding_set, GDK_x, GDK_CONTROL_MASK,
+                                 "cut_clipboard", 0);
+    gtk_binding_entry_add_signal(binding_set, GDK_c, GDK_CONTROL_MASK,
+                                 "copy_clipboard", 0);
+    gtk_binding_entry_add_signal(binding_set, GDK_v, GDK_CONTROL_MASK,
+                                 "paste_clipboard", 0);
+
+    gtk_binding_entry_add_signal(binding_set, GDK_Delete, GDK_SHIFT_MASK,
+                                 "cut_clipboard", 0);
+    gtk_binding_entry_add_signal(binding_set, GDK_Insert, GDK_CONTROL_MASK,
+                                 "copy_clipboard", 0);
+    gtk_binding_entry_add_signal(binding_set, GDK_Insert, GDK_SHIFT_MASK,
+                                 "paste_clipboard", 0);
+
+    /*
+     * properties
+     */
+    g_object_class_install_property(objectClass, PROP_COPY_TARGET_LIST,
+                                    g_param_spec_boxed("copy-target-list",
+                                                       "Target list",
+                                                       "The list of targets this Web view supports for copying to the clipboard",
+                                                       GTK_TYPE_TARGET_LIST,
+                                                       WEBKIT_PARAM_READABLE));
+
+    g_object_class_install_property(objectClass, PROP_PASTE_TARGET_LIST,
+                                    g_param_spec_boxed("paste-target-list",
+                                                       "Target list",
+                                                       "The list of targets this Web view supports for pasting to the clipboard",
+                                                       GTK_TYPE_TARGET_LIST,
+                                                       WEBKIT_PARAM_READABLE));
+
+    g_object_class_install_property(objectClass, PROP_SETTINGS,
+                                    g_param_spec_object("settings",
+                                                        "Settings",
+                                                        "An associated WebKitWebSettings instance",
+                                                        WEBKIT_TYPE_WEB_SETTINGS,
+                                                        WEBKIT_PARAM_READWRITE));
+
+    g_object_class_install_property(objectClass, PROP_EDITABLE,
+                                    g_param_spec_boolean("editable",
+                                                         "Editable",
+                                                         "Whether content can be modified by the user",
+                                                         FALSE,
+                                                         WEBKIT_PARAM_READWRITE));
+
+    g_object_class_install_property(objectClass, PROP_TRANSPARENT,
+                                    g_param_spec_boolean("transparent",
+                                                         "Transparent",
+                                                         "Whether content has a transparent background",
+                                                         FALSE,
+                                                         WEBKIT_PARAM_READWRITE));
+
+    g_type_class_add_private(webViewClass, sizeof(WebKitWebViewPrivate));
+}
+
+static void webkit_web_view_screen_changed(WebKitWebView* webView, GdkScreen* previousScreen, gpointer userdata)
+{
+    WebKitWebViewPrivate* priv = webView->priv;
+    WebKitWebSettings* webSettings = priv->webSettings;
+    Settings* settings = core(webView)->settings();
+
+    guint defaultFontSize, defaultMonospaceFontSize, minimumFontSize, minimumLogicalFontSize;
+
+    g_object_get(G_OBJECT(webSettings),
+                 "default-font-size", &defaultFontSize,
+                 "default-monospace-font-size", &defaultMonospaceFontSize,
+                 "minimum-font-size", &minimumFontSize,
+                 "minimum-logical-font-size", &minimumLogicalFontSize,
+                 NULL);
+
+    gdouble DPI = defaultDPI;
+#if GTK_CHECK_VERSION(2,10,0)
+    GdkScreen* screen = gtk_widget_has_screen(GTK_WIDGET(webView)) ? gtk_widget_get_screen(GTK_WIDGET(webView)) : gdk_screen_get_default();
+    if (screen) {
+        DPI = gdk_screen_get_resolution(screen);
+        // gdk_screen_get_resolution() returns -1 when no DPI is set.
+        if (DPI == -1)
+            DPI = defaultDPI;
+    }
+#endif
+    ASSERT(DPI > 0);
+    settings->setDefaultFontSize(defaultFontSize / 72.0 * DPI);
+    settings->setDefaultFixedFontSize(defaultMonospaceFontSize / 72.0 * DPI);
+    settings->setMinimumFontSize(minimumFontSize / 72.0 * DPI);
+    settings->setMinimumLogicalFontSize(minimumLogicalFontSize / 72.0 * DPI);
+}
+
+static void webkit_web_view_update_settings(WebKitWebView* webView)
+{
+    WebKitWebViewPrivate* priv = webView->priv;
+    WebKitWebSettings* webSettings = priv->webSettings;
+    Settings* settings = core(webView)->settings();
+
+    gchar* defaultEncoding, *cursiveFontFamily, *defaultFontFamily, *fantasyFontFamily, *monospaceFontFamily, *sansSerifFontFamily, *serifFontFamily, *userStylesheetUri;
+    gboolean autoLoadImages, autoShrinkImages, printBackgrounds, enableScripts, enablePlugins, resizableTextAreas;
+
+    g_object_get(G_OBJECT(webSettings),
+                 "default-encoding", &defaultEncoding,
+                 "cursive-font-family", &cursiveFontFamily,
+                 "default-font-family", &defaultFontFamily,
+                 "fantasy-font-family", &fantasyFontFamily,
+                 "monospace-font-family", &monospaceFontFamily,
+                 "sans-serif-font-family", &sansSerifFontFamily,
+                 "serif-font-family", &serifFontFamily,
+                 "auto-load-images", &autoLoadImages,
+                 "auto-shrink-images", &autoShrinkImages,
+                 "print-backgrounds", &printBackgrounds,
+                 "enable-scripts", &enableScripts,
+                 "enable-plugins", &enablePlugins,
+                 "resizable-text-areas", &resizableTextAreas,
+                 "user-stylesheet-uri", &userStylesheetUri,
+                 NULL);
+
+    settings->setDefaultTextEncodingName(defaultEncoding);
+    settings->setCursiveFontFamily(cursiveFontFamily);
+    settings->setStandardFontFamily(defaultFontFamily);
+    settings->setFantasyFontFamily(fantasyFontFamily);
+    settings->setFixedFontFamily(monospaceFontFamily);
+    settings->setSansSerifFontFamily(sansSerifFontFamily);
+    settings->setSerifFontFamily(serifFontFamily);
+    settings->setLoadsImagesAutomatically(autoLoadImages);
+    settings->setShrinksStandaloneImagesToFit(autoShrinkImages);
+    settings->setShouldPrintBackgrounds(printBackgrounds);
+    settings->setJavaScriptEnabled(enableScripts);
+    settings->setPluginsEnabled(enablePlugins);
+    settings->setTextAreasAreResizable(resizableTextAreas);
+    settings->setUserStyleSheetLocation(KURL(userStylesheetUri));
+
+    g_free(defaultEncoding);
+    g_free(cursiveFontFamily);
+    g_free(defaultFontFamily);
+    g_free(fantasyFontFamily);
+    g_free(monospaceFontFamily);
+    g_free(sansSerifFontFamily);
+    g_free(serifFontFamily);
+    g_free(userStylesheetUri);
+
+    webkit_web_view_screen_changed(webView, NULL, NULL);
+}
+
+static void webkit_web_view_settings_notify(WebKitWebSettings* webSettings, GParamSpec* pspec, WebKitWebView* webView)
+{
+    Settings* settings = core(webView)->settings();
+
+    const gchar* name = g_intern_string(pspec->name);
+    GValue value = {0, 0};
+    g_value_init(&value, pspec->value_type);
+    g_object_get_property(G_OBJECT(webSettings), name, &value);
+
+    if (name == g_intern_string("default-encoding"))
+        settings->setDefaultTextEncodingName(g_value_get_string(&value));
+    else if (name == g_intern_string("cursive-font-family"))
+        settings->setCursiveFontFamily(g_value_get_string(&value));
+    else if (name == g_intern_string("default-font-family"))
+        settings->setStandardFontFamily(g_value_get_string(&value));
+    else if (name == g_intern_string("fantasy-font-family"))
+        settings->setFantasyFontFamily(g_value_get_string(&value));
+    else if (name == g_intern_string("monospace-font-family"))
+        settings->setFixedFontFamily(g_value_get_string(&value));
+    else if (name == g_intern_string("sans-serif-font-family"))
+        settings->setSansSerifFontFamily(g_value_get_string(&value));
+    else if (name == g_intern_string("serif-font-family"))
+        settings->setSerifFontFamily(g_value_get_string(&value));
+    else if (name == g_intern_string("default-font-size"))
+        settings->setDefaultFontSize(g_value_get_int(&value));
+    else if (name == g_intern_string("default-monospace-font-size"))
+        settings->setDefaultFixedFontSize(g_value_get_int(&value));
+    else if (name == g_intern_string("minimum-font-size"))
+        settings->setMinimumFontSize(g_value_get_int(&value));
+    else if (name == g_intern_string("minimum-logical-font-size"))
+        settings->setMinimumLogicalFontSize(g_value_get_int(&value));
+    else if (name == g_intern_string("auto-load-images"))
+        settings->setLoadsImagesAutomatically(g_value_get_boolean(&value));
+    else if (name == g_intern_string("auto-shrink-images"))
+        settings->setShrinksStandaloneImagesToFit(g_value_get_boolean(&value));
+    else if (name == g_intern_string("print-backgrounds"))
+        settings->setShouldPrintBackgrounds(g_value_get_boolean(&value));
+    else if (name == g_intern_string("enable-scripts"))
+        settings->setJavaScriptEnabled(g_value_get_boolean(&value));
+    else if (name == g_intern_string("enable-plugins"))
+        settings->setPluginsEnabled(g_value_get_boolean(&value));
+    else if (name == g_intern_string("resizable-text-areas"))
+        settings->setTextAreasAreResizable(g_value_get_boolean(&value));
+    else if (name == g_intern_string("user-stylesheet-uri"))
+        settings->setUserStyleSheetLocation(KURL(g_value_get_string(&value)));
+    else
+        g_warning("Unexpected setting '%s'", name);
+    g_value_unset(&value);
+}
+
+static void webkit_web_view_init(WebKitWebView* webView)
+{
+    WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);
+    webView->priv = priv;
+
+    priv->imContext = gtk_im_multicontext_new();
+    priv->corePage = new Page(new WebKit::ChromeClient(webView), new WebKit::ContextMenuClient, new WebKit::EditorClient(webView), new WebKit::DragClient, new WebKit::InspectorClient);
+
+    GTK_WIDGET_SET_FLAGS(webView, GTK_CAN_FOCUS);
+    priv->mainFrame = WEBKIT_WEB_FRAME(webkit_web_frame_new(webView));
+    priv->lastPopupXPosition = priv->lastPopupYPosition = -1;
+    priv->editable = false;
+
+    priv->backForwardList = webkit_web_back_forward_list_new_with_web_view(webView);
+
+#if GTK_CHECK_VERSION(2,10,0)
+    GdkAtom textHtml = gdk_atom_intern_static_string("text/html");
+#else
+    GdkAtom textHtml = gdk_atom_intern("text/html", false);
+#endif
+    /* Targets for copy */
+    priv->copy_target_list = gtk_target_list_new(NULL, 0);
+    gtk_target_list_add(priv->copy_target_list, textHtml, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML);
+    gtk_target_list_add_text_targets(priv->copy_target_list, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT);
+
+    /* Targets for pasting */
+    priv->paste_target_list = gtk_target_list_new(NULL, 0);
+    gtk_target_list_add(priv->paste_target_list, textHtml, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML);
+    gtk_target_list_add_text_targets(priv->paste_target_list, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT);
+
+    priv->webSettings = webkit_web_settings_new();
+    webkit_web_view_update_settings(webView);
+    g_signal_connect(webView, "screen-changed", G_CALLBACK(webkit_web_view_screen_changed), NULL);
+    g_signal_connect(priv->webSettings, "notify", G_CALLBACK(webkit_web_view_settings_notify), webView);
+}
+
+GtkWidget* webkit_web_view_new(void)
+{
+    WebKitWebView* webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW, NULL));
+
+    return GTK_WIDGET(webView);
+}
+
+void webkit_web_view_set_settings(WebKitWebView* webView, WebKitWebSettings* webSettings)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+    g_return_if_fail(WEBKIT_IS_WEB_SETTINGS(webSettings));
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    g_signal_handlers_disconnect_by_func(priv->webSettings, (gpointer)webkit_web_view_settings_notify, webView);
+    g_object_unref(priv->webSettings);
+    g_object_ref(webSettings);
+    priv->webSettings = webSettings;
+    webkit_web_view_update_settings(webView);
+    g_signal_connect(webSettings, "notify", G_CALLBACK(webkit_web_view_settings_notify), webView);
+}
+
+WebKitWebSettings* webkit_web_view_get_settings(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    return priv->webSettings;
+}
+
+/**
+ * webkit_web_view_set_maintains_back_forward_list:
+ * @webView: a #WebKitWebView
+ * @flag: to tell the view to maintain a back or forward list
+ *
+ * Set the view to maintain a back or forward list of history items.
+ */
+void webkit_web_view_set_maintains_back_forward_list(WebKitWebView* webView, gboolean flag)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    core(webView)->backForwardList()->setEnabled(flag);
+}
+
+/**
+ * webkit_web_view_get_back_forward_list:
+ * @webView: a #WebKitWebView
+ *
+ * Returns a #WebKitWebBackForwardList
+ *
+ * Return value: the #WebKitWebBackForwardList
+ */
+WebKitWebBackForwardList* webkit_web_view_get_back_forward_list(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    if (!core(webView) || !core(webView)->backForwardList()->enabled())
+        return NULL;
+
+    return priv->backForwardList;
+}
+
+/**
+ * webkit_web_view_go_to_back_forward_item:
+ * @webView: a #WebKitWebView
+ * @item: a #WebKitWebHistoryItem*
+ *
+ * Go to the specified #WebKitWebHistoryItem
+ *
+ * Return value: %TRUE if loading of item is successful, %FALSE if not
+ */
+gboolean webkit_web_view_go_to_back_forward_item(WebKitWebView* webView, WebKitWebHistoryItem* item)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+    g_return_val_if_fail(WEBKIT_IS_WEB_HISTORY_ITEM(item), FALSE);
+
+    // FIXME: This always returns TRUE
+    core(webView)->goToItem(core(item), FrameLoadTypeIndexedBackForward);
+    return TRUE;
+}
+
+/**
+ * webkit_web_view_go_backward:
+ * @webView: the #WebKitWebView
+ *
+ * @Deprecated: Use webkit_web_view_go_back() instead.
+ *
+ * Go to the previous page, if there's any.
+ */
+void webkit_web_view_go_backward(WebKitWebView* webView)
+{
+    g_warning("webkit_web_view_go_backward() is obsolete; use webkit_web_view_go_back()");
+    webkit_web_view_go_back(webView);
+}
+
+/**
+ * webkit_web_view_go_back:
+ * @web_view: a #WebKitWebView
+ *
+ * Loads the previous history item.
+ */
+void webkit_web_view_go_back(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    core(webView)->goBack();
+}
+
+/**
+ * webkit_web_view_go_back_or_forward:
+ * @web_view: a #WebKitWebView
+ * @steps: the number of steps
+ *
+ * Loads the history item that is the number of @steps away from the current
+ * item. Negative values represent steps backward while positive values
+ * represent steps forward.
+ */
+void webkit_web_view_go_back_or_forward(WebKitWebView* webView, gint steps)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    Frame* frame = core(webView)->mainFrame();
+    frame->loader()->goBackOrForward(steps);
+}
+
+/**
+ * webkit_web_view_go_forward:
+ * @web_view: a #WebKitWebView
+ *
+ * Loads the next history item.
+ */
+void webkit_web_view_go_forward(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    core(webView)->goForward();
+}
+
+/**
+ * webkit_web_view_can_go_backward:
+ * @webView: the #WebKitWebView
+ *
+ * Checks whether the view can go back to the previous page
+ *
+ * @Deprecated: Use webkit_web_view_can_go_back() instead.
+ *
+ * Return value: %TRUE if the page can go back, otherwise returns %FALSE
+ */
+gboolean webkit_web_view_can_go_backward(WebKitWebView* webView)
+{
+    g_warning("webkit_web_view_can_go_backward() is obsolete; use webkit_web_view_can_go_back()");
+    return webkit_web_view_can_go_back(webView);
+}
+
+/**
+ * webkit_web_view_can_go_back:
+ * @web_view: a #WebKitWebView
+ *
+ * Determines whether #web_view has a previous history item.
+ *
+ * Return value: %TRUE if able to move back, %FALSE otherwise
+ */
+gboolean webkit_web_view_can_go_back(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    if (!core(webView) || !core(webView)->backForwardList()->backItem())
+        return FALSE;
+
+    return TRUE;
+}
+
+/**
+ * webkit_web_view_can_go_back_or_forward:
+ * @web_view: a #WebKitWebView
+ * @steps: the number of steps
+ *
+ * Determines whether #web_view has a history item of @steps. Negative values
+ * represent steps backward while positive values represent steps forward.
+ *
+ * Return value: %TRUE if able to move back or forward the given number of
+ * steps, %FALSE otherwise
+ */
+gboolean webkit_web_view_can_go_back_or_forward(WebKitWebView* webView, gint steps)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    Frame* frame = core(webView)->mainFrame();
+    return frame->loader()->canGoBackOrForward(steps);
+}
+
+/**
+ * webkit_web_view_can_go_forward:
+ * @web_view: a #WebKitWebView
+ *
+ * Determines whether #web_view has a next history item.
+ *
+ * Return value: %TRUE if able to move forward, %FALSE otherwise
+ */
+gboolean webkit_web_view_can_go_forward(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    Page* page = core(webView);
+
+    if (!page)
+        return FALSE;
+
+    if (!page->backForwardList()->forwardItem())
+        return FALSE;
+
+    return TRUE;
+}
+
+void webkit_web_view_open(WebKitWebView* webView, const gchar* uri)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+    g_return_if_fail(uri);
+
+    Frame* frame = core(webView)->mainFrame();
+    frame->loader()->load(ResourceRequest(KURL(String::fromUTF8(uri))));
+}
+
+void webkit_web_view_reload(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    core(webView)->mainFrame()->loader()->reload();
+}
+
+void webkit_web_view_load_string(WebKitWebView* webView, const gchar* content, const gchar* contentMimeType, const gchar* contentEncoding, const gchar* baseUri)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+    g_return_if_fail(content);
+
+    Frame* frame = core(webView)->mainFrame();
+
+    KURL url(baseUri ? String::fromUTF8(baseUri) : "");
+    RefPtr<SharedBuffer> sharedBuffer = new SharedBuffer(strdup(content), strlen(content));
+    SubstituteData substituteData(sharedBuffer.release(), contentMimeType ? String(contentMimeType) : "text/html", contentEncoding ? String(contentEncoding) : "UTF-8", KURL("about:blank"), url);
+
+    frame->loader()->load(ResourceRequest(url), substituteData);
+}
+
+void webkit_web_view_load_html_string(WebKitWebView* webView, const gchar* content, const gchar* baseUri)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+    g_return_if_fail(content);
+
+    webkit_web_view_load_string(webView, content, NULL, NULL, baseUri);
+}
+
+void webkit_web_view_stop_loading(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    Frame* frame = core(webView)->mainFrame();
+
+    if (FrameLoader* loader = frame->loader())
+        loader->stopAllLoaders();
+}
+
+/**
+ * webkit_web_view_search_text:
+ * @web_view: a #WebKitWebView
+ * @text: a string to look for
+ * @forward: whether to find forward or not
+ * @case_sensitive: whether to respect the case of text
+ * @wrap: whether to continue looking at the beginning after reaching the end
+ *
+ * Looks for a specified string inside #web_view.
+ *
+ * Return value: %TRUE on success or %FALSE on failure
+ */
+gboolean webkit_web_view_search_text(WebKitWebView* webView, const gchar* string, gboolean caseSensitive, gboolean forward, gboolean shouldWrap)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+    g_return_val_if_fail(string, FALSE);
+
+    TextCaseSensitivity caseSensitivity = caseSensitive ? TextCaseSensitive : TextCaseInsensitive;
+    FindDirection direction = forward ? FindDirectionForward : FindDirectionBackward;
+
+    return core(webView)->findString(String::fromUTF8(string), caseSensitivity, direction, shouldWrap);
+}
+
+/**
+ * webkit_web_view_mark_text_matches:
+ * @web_view: a #WebKitWebView
+ * @string: a string to look for
+ * @case_sensitive: whether to respect the case of text
+ * @limit: the maximum number of strings to look for or %0 for all
+ *
+ * Attempts to highlight all occurances of #string inside #web_view.
+ *
+ * Return value: the number of strings highlighted
+ */
+guint webkit_web_view_mark_text_matches(WebKitWebView* webView, const gchar* string, gboolean caseSensitive, guint limit)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
+    g_return_val_if_fail(string, 0);
+
+    TextCaseSensitivity caseSensitivity = caseSensitive ? TextCaseSensitive : TextCaseInsensitive;
+
+    return core(webView)->markAllMatchesForText(String::fromUTF8(string), caseSensitivity, false, limit);
+}
+
+/**
+ * webkit_web_view_set_highlight_text_matches:
+ * @web_view: a #WebKitWebView
+ * @highlight: whether to highlight text matches
+ *
+ * Highlights text matches previously marked by webkit_web_view_mark_text_matches.
+ */
+void webkit_web_view_set_highlight_text_matches(WebKitWebView* webView, gboolean shouldHighlight)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    core(webView)->mainFrame()->setMarkedTextMatchesAreHighlighted(shouldHighlight);
+}
+
+/**
+ * webkit_web_view_unmark_text_matches:
+ * @web_view: a #WebKitWebView
+ *
+ * Removes highlighting previously set by webkit_web_view_mark_text_matches.
+ */
+void webkit_web_view_unmark_text_matches(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    return core(webView)->unmarkAllTextMatches();
+}
+
+WebKitWebFrame* webkit_web_view_get_main_frame(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    return priv->mainFrame;
+}
+
+/**
+ * webkit_web_view_get_focused_frame:
+ * @web_view: a #WebKitWebView
+ *
+ * Returns the frame that has focus or an active text selection.
+ *
+ * Return value: The focused #WebKitWebFrame or %NULL if no frame is focused
+ */
+WebKitWebFrame* webkit_web_view_get_focused_frame(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    Frame* focusedFrame = core(webView)->focusController()->focusedFrame();
+    return kit(focusedFrame);
+}
+
+void webkit_web_view_execute_script(WebKitWebView* webView, const gchar* script)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+    g_return_if_fail(script);
+
+    if (FrameLoader* loader = core(webView)->mainFrame()->loader())
+        loader->executeScript(String::fromUTF8(script), true);
+}
+
+/**
+ * webkit_web_view_cut_clipboard:
+ * @web_view: a #WebKitWebView
+ *
+ * Determines whether or not it is currently possible to cut to the clipboard.
+ *
+ * Return value: %TRUE if a selection can be cut, %FALSE if not
+ */
+gboolean webkit_web_view_can_cut_clipboard(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    return frame->editor()->canCut() || frame->editor()->canDHTMLCut();
+}
+
+/**
+ * webkit_web_view_copy_clipboard:
+ * @web_view: a #WebKitWebView
+ *
+ * Determines whether or not it is currently possible to copy to the clipboard.
+ *
+ * Return value: %TRUE if a selection can be copied, %FALSE if not
+ */
+gboolean webkit_web_view_can_copy_clipboard(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    return frame->editor()->canCopy() || frame->editor()->canDHTMLCopy();
+}
+
+/**
+ * webkit_web_view_paste_clipboard:
+ * @web_view: a #WebKitWebView
+ *
+ * Determines whether or not it is currently possible to paste from the clipboard.
+ *
+ * Return value: %TRUE if a selection can be pasted, %FALSE if not
+ */
+gboolean webkit_web_view_can_paste_clipboard(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    return frame->editor()->canPaste() || frame->editor()->canDHTMLPaste();
+}
+
+/**
+ * webkit_web_view_cut_clipboard:
+ * @web_view: a #WebKitWebView
+ *
+ * Cuts the current selection inside the @web_view to the clipboard.
+ */
+void webkit_web_view_cut_clipboard(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    if (webkit_web_view_can_cut_clipboard(webView))
+        g_signal_emit(webView, webkit_web_view_signals[CUT_CLIPBOARD], 0);
+}
+
+/**
+ * webkit_web_view_copy_clipboard:
+ * @web_view: a #WebKitWebView
+ *
+ * Copies the current selection inside the @web_view to the clipboard.
+ */
+void webkit_web_view_copy_clipboard(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    if (webkit_web_view_can_copy_clipboard(webView))
+        g_signal_emit(webView, webkit_web_view_signals[COPY_CLIPBOARD], 0);
+}
+
+/**
+ * webkit_web_view_paste_clipboard:
+ * @web_view: a #WebKitWebView
+ *
+ * Pastes the current contents of the clipboard to the @web_view.
+ */
+void webkit_web_view_paste_clipboard(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    if (webkit_web_view_can_paste_clipboard(webView))
+        g_signal_emit(webView, webkit_web_view_signals[PASTE_CLIPBOARD], 0);
+}
+
+/**
+ * webkit_web_view_delete_selection:
+ * @web_view: a #WebKitWebView
+ *
+ * Deletes the current selection inside the @web_view.
+ */
+void webkit_web_view_delete_selection(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    frame->editor()->performDelete();
+}
+
+/**
+ * webkit_web_view_has_selection:
+ * @web_view: a #WebKitWebView
+ *
+ * Determines whether text was selected.
+ *
+ * Return value: %TRUE if there is selected text, %FALSE if not
+ */
+gboolean webkit_web_view_has_selection(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    return !core(webView)->selection().isNone();
+}
+
+/**
+ * webkit_web_view_get_selected_text:
+ * @web_view: a #WebKitWebView
+ *
+ * Retrieves the selected text if any.
+ *
+ * Return value: a newly allocated string with the selection or %NULL
+ */
+gchar* webkit_web_view_get_selected_text(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
+
+    Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
+    return g_strdup(frame->selectedText().utf8().data());
+}
+
+/**
+ * webkit_web_view_select_all:
+ * @web_view: a #WebKitWebView
+ *
+ * Attempts to select everything inside the @web_view.
+ */
+void webkit_web_view_select_all(WebKitWebView* webView)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    g_signal_emit(webView, webkit_web_view_signals[SELECT_ALL], 0);
+}
+
+/**
+ * webkit_web_view_get_editable:
+ * @web_view: a #WebKitWebView
+ *
+ * Returns whether the user is allowed to edit the document.
+ *
+ * Returns %TRUE if @web_view allows the user to edit the HTML document, %FALSE if
+ * it doesn't. You can change @web_view's document programmatically regardless of
+ * this setting.
+ *
+ * Return value: a #gboolean indicating the editable state
+ */
+gboolean webkit_web_view_get_editable(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    return priv->editable;
+}
+
+/**
+ * webkit_web_view_set_editable:
+ * @web_view: a #WebKitWebView
+ * @flag: a #gboolean indicating the editable state
+ *
+ * Sets whether @web_view allows the user to edit its HTML document.
+ *
+ * If @flag is %TRUE, @web_view allows the user to edit the document. If @flag is
+ * %FALSE, an element in @web_view's document can only be edited if the
+ * CONTENTEDITABLE attribute has been set on the element or one of its parent
+ * elements. You can change @web_view's document programmatically regardless of
+ * this setting. By default a #WebKitWebView is not editable.
+
+ * Normally, an HTML document is not editable unless the elements within the
+ * document are editable. This function provides a low-level way to make the
+ * contents of a #WebKitWebView editable without altering the document or DOM
+ * structure.
+ */
+void webkit_web_view_set_editable(WebKitWebView* webView, gboolean flag)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    WebKitWebViewPrivate* priv = webView->priv;
+
+    Frame* frame = core(webView)->mainFrame();
+    g_return_if_fail(frame);
+
+    // TODO: What happens when the frame is replaced?
+    flag = flag != FALSE;
+    if (flag == priv->editable)
+        return;
+
+    priv->editable = flag;
+
+    if (flag) {
+        frame->applyEditingStyleToBodyElement();
+        // TODO: If the WebKitWebView is made editable and the selection is empty, set it to something.
+        //if (!webkit_web_view_get_selected_dom_range(webView))
+        //    mainFrame->setSelectionFromNone();
+    } else
+        frame->removeEditingStyleFromBodyElement();
+}
+
+/**
+ * webkit_web_view_get_copy_target_list:
+ * @web_view: a #WebKitWebView
+ *
+ * This function returns the list of targets this #WebKitWebView can
+ * provide for clipboard copying and as DND source. The targets in the list are
+ * added with %info values from the #WebKitWebViewTargetInfo enum,
+ * using gtk_target_list_add() and
+ * gtk_target_list_add_text_targets().
+ *
+ * Return value: the #GtkTargetList
+ **/
+GtkTargetList* webkit_web_view_get_copy_target_list(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    return priv->copy_target_list;
+}
+
+/**
+ * webkit_web_view_get_paste_target_list:
+ * @web_view: a #WebKitWebView
+ *
+ * This function returns the list of targets this #WebKitWebView can
+ * provide for clipboard pasting and as DND destination. The targets in the list are
+ * added with %info values from the #WebKitWebViewTargetInfo enum,
+ * using gtk_target_list_add() and
+ * gtk_target_list_add_text_targets().
+ *
+ * Return value: the #GtkTargetList
+ **/
+GtkTargetList* webkit_web_view_get_paste_target_list(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    return priv->paste_target_list;
+}
+
+/**
+ * webkit_web_view_get_transparent:
+ * @web_view: a #WebKitWebView
+ *
+ * Returns whether the #WebKitWebView has a transparent background.
+ *
+ * Return value: %FALSE when the #WebKitWebView draws a solid background
+ * (the default), otherwise %TRUE.
+ */
+gboolean webkit_web_view_get_transparent(WebKitWebView* webView)
+{
+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL);
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    return priv->transparent;
+}
+
+/**
+ * webkit_web_view_set_transparent:
+ * @web_view: a #WebKitWebView
+ *
+ * Sets whether the #WebKitWebView has a transparent background.
+ *
+ * Pass %FALSE to have the #WebKitWebView draw a solid background
+ * (the default), otherwise %TRUE.
+ */
+void webkit_web_view_set_transparent(WebKitWebView* webView, gboolean flag)
+{
+    g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
+
+    WebKitWebViewPrivate* priv = webView->priv;
+    priv->transparent = flag;
+
+    // TODO: This needs to be made persistent or it could become a problem when
+    // the main frame is replaced.
+    Frame* frame = core(webView)->mainFrame();
+    g_return_if_fail(frame);
+    frame->view()->setTransparent(flag);
+}
+
+}
diff --git a/WebKit/gtk/webkit/webkitwebview.h b/WebKit/gtk/webkit/webkitwebview.h
new file mode 100644
index 0000000..0c5a675
--- /dev/null
+++ b/WebKit/gtk/webkit/webkitwebview.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2007 Holger Hans Peter Freyther
+ * Copyright (C) 2007, 2008 Alp Toker <alp@atoker.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WEBKIT_WEB_VIEW_H
+#define WEBKIT_WEB_VIEW_H
+
+#include <gtk/gtk.h>
+#include <JavaScriptCore/JSBase.h>
+
+#include <webkit/webkitdefines.h>
+#include <webkit/webkitwebbackforwardlist.h>
+#include <webkit/webkitwebhistoryitem.h>
+#include <webkit/webkitwebsettings.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_WEB_VIEW            (webkit_web_view_get_type())
+#define WEBKIT_WEB_VIEW(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_WEB_VIEW, WebKitWebView))
+#define WEBKIT_WEB_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_WEB_VIEW, WebKitWebViewClass))
+#define WEBKIT_IS_WEB_VIEW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_WEB_VIEW))
+#define WEBKIT_IS_WEB_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_WEB_VIEW))
+#define WEBKIT_WEB_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_WEB_VIEW, WebKitWebViewClass))
+
+typedef struct _WebKitWebViewPrivate WebKitWebViewPrivate;
+
+typedef enum {
+    WEBKIT_NAVIGATION_RESPONSE_ACCEPT,
+    WEBKIT_NAVIGATION_RESPONSE_IGNORE,
+    WEBKIT_NAVIGATION_RESPONSE_DOWNLOAD
+} WebKitNavigationResponse;
+
+typedef enum
+{
+    WEBKIT_WEB_VIEW_TARGET_INFO_HTML = - 1,
+    WEBKIT_WEB_VIEW_TARGET_INFO_TEXT = - 2
+} WebKitWebViewTargetInfo;
+
+struct _WebKitWebView {
+    GtkContainer parent_instance;
+
+    WebKitWebViewPrivate* priv;
+};
+
+struct _WebKitWebViewClass {
+    GtkContainerClass parent_class;
+
+    /*
+     * default handler/virtual methods
+     * DISCUSS: create_web_view needs a request and should we make this a signal with default handler? this would
+     * require someone doing a g_signal_stop_emission_by_name
+     * WebUIDelegate has nothing for create_frame, WebPolicyDelegate as well...
+     */
+    WebKitWebView*  (*create_web_view)  (WebKitWebView* web_view);
+
+    /*
+     * TODO: FIXME: Create something like WebPolicyDecisionListener_Protocol instead
+     */
+    WebKitNavigationResponse (*navigation_requested) (WebKitWebView* web_view, WebKitWebFrame* frame, WebKitNetworkRequest* request);
+
+    void (*window_object_cleared) (WebKitWebView* web_view, WebKitWebFrame* frame, JSGlobalContextRef context, JSObjectRef window_object);
+    gchar*   (*choose_file) (WebKitWebView* web_view, WebKitWebFrame* frame, const gchar* old_file);
+    gboolean (*script_alert) (WebKitWebView* web_view, WebKitWebFrame* frame, const gchar* alert_message);
+    gboolean (*script_confirm) (WebKitWebView* web_view, WebKitWebFrame* frame, const gchar* confirm_message, gboolean* did_confirm);
+    gboolean (*script_prompt) (WebKitWebView* web_view, WebKitWebFrame* frame, const gchar* message, const gchar* default_value, gchar** value);
+    gboolean (*console_message) (WebKitWebView* web_view, const gchar* message, unsigned int line_number, const gchar* source_id);
+    void (*select_all) (WebKitWebView* web_view);
+    void (*cut_clipboard) (WebKitWebView* web_view);
+    void (*copy_clipboard) (WebKitWebView* web_view);
+    void (*paste_clipboard) (WebKitWebView* web_view);
+
+    /*
+     * internal
+     */
+    void   (*set_scroll_adjustments) (WebKitWebView*, GtkAdjustment*, GtkAdjustment*);
+};
+
+WEBKIT_API GType
+webkit_web_view_get_type (void);
+
+WEBKIT_API GtkWidget*
+webkit_web_view_new (void);
+
+WEBKIT_API void
+webkit_web_view_set_maintains_back_forward_list (WebKitWebView* web_view, gboolean flag);
+
+WEBKIT_API WebKitWebBackForwardList*
+webkit_web_view_get_back_forward_list (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_go_to_back_forward_item (WebKitWebView *web_view, WebKitWebHistoryItem* item);
+
+WEBKIT_API gboolean
+webkit_web_view_can_go_back (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_can_go_back_or_forward (WebKitWebView* web_view, gint steps);
+
+WEBKIT_API gboolean
+webkit_web_view_can_go_forward (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_go_back (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_go_back_or_forward (WebKitWebView* web_view, gint steps);
+
+WEBKIT_API void
+webkit_web_view_go_forward (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_stop_loading (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_open (WebKitWebView* web_view, const gchar* uri);
+
+WEBKIT_API void
+webkit_web_view_reload (WebKitWebView *web_view);
+
+WEBKIT_API void
+webkit_web_view_load_string (WebKitWebView* web_view, const gchar* content, const gchar* content_mime_type, const gchar* content_encoding, const gchar* base_uri);
+
+WEBKIT_API void
+webkit_web_view_load_html_string (WebKitWebView* web_view, const gchar* content, const gchar* base_uri);
+
+WEBKIT_API gboolean
+webkit_web_view_search_text (WebKitWebView* web_view, const gchar* string, gboolean case_sensitive, gboolean forward, gboolean wrap);
+
+WEBKIT_API guint
+webkit_web_view_mark_text_matches (WebKitWebView* web_view, const gchar* string, gboolean case_sensitive, guint limit);
+
+WEBKIT_API void
+webkit_web_view_set_highlight_text_matches (WebKitWebView* web_view, gboolean highlight);
+
+WEBKIT_API void
+webkit_web_view_unmark_text_matches (WebKitWebView* web_view);
+
+WEBKIT_API WebKitWebFrame*
+webkit_web_view_get_main_frame (WebKitWebView* web_view);
+
+WEBKIT_API WebKitWebFrame*
+webkit_web_view_get_focused_frame (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_execute_script (WebKitWebView* web_view, const gchar* script);
+
+WEBKIT_API gboolean
+webkit_web_view_can_cut_clipboard (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_can_copy_clipboard (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_can_paste_clipboard (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_cut_clipboard (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_copy_clipboard (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_paste_clipboard (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_delete_selection (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_has_selection (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_select_all (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_get_editable (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_set_editable (WebKitWebView* web_view, gboolean flag);
+
+WEBKIT_API GtkTargetList*
+webkit_web_view_get_copy_target_list (WebKitWebView* web_view);
+
+WEBKIT_API GtkTargetList*
+webkit_web_view_get_paste_target_list (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_set_settings (WebKitWebView* web_view, WebKitWebSettings* settings);
+
+WEBKIT_API WebKitWebSettings*
+webkit_web_view_get_settings (WebKitWebView* web_view);
+
+WEBKIT_OBSOLETE_API gboolean
+webkit_web_view_can_go_backward (WebKitWebView* web_view);
+
+WEBKIT_OBSOLETE_API void
+webkit_web_view_go_backward (WebKitWebView* web_view);
+
+WEBKIT_API gboolean
+webkit_web_view_get_transparent (WebKitWebView* web_view);
+
+WEBKIT_API void
+webkit_web_view_set_transparent (WebKitWebView* web_view, gboolean flag);
+
+G_END_DECLS
+
+#endif