2008-11-03 Cameron Zwarich <zwarich@apple.com>

Rubber-stamped by Maciej Stachowiak.

/*

* Copyright (C) 2007, 2008 Christian Dywan <christian@imendio.com>

* Copyright (C) 2008 Nuanti Ltd.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

#include "FileSystem.h"

#include "FileChooser.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"

ChromeClient::ChromeClient(WebKitWebView* webView)

: m_webView(webView)

{

}

void ChromeClient::chromeDestroyed()

FloatRect ChromeClient::windowRect()

{

GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));

gint left, top, width, height;

gtk_window_get_position(GTK_WINDOW(window), &left, &top);

gtk_window_get_size(GTK_WINDOW(window), &width, &height);

return FloatRect();

}

{

}

FloatRect ChromeClient::pageRect()

{

GtkAllocation allocation = GTK_WIDGET(m_webView)->allocation;

return IntRect(allocation.x, allocation.y, allocation.width, allocation.height);

}

void ChromeClient::focus()

{

gtk_widget_grab_focus(GTK_WIDGET(m_webView));

}

void ChromeClient::unfocus()

{

GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));

gtk_window_set_focus(GTK_WINDOW(window), NULL);

}

{

return 0;

}

void ChromeClient::show()

{

}

bool ChromeClient::canRunModal()

notImplemented();

}

{

}

bool ChromeClient::toolbarsVisible()

{

}

{

}

bool ChromeClient::statusbarVisible()

{

}

{

}

bool ChromeClient::scrollbarsVisible() {

}

{

}

bool ChromeClient::menubarVisible()

{

}

void ChromeClient::setResizable(bool)

{

}

void ChromeClient::closeWindowSoon()

bool ChromeClient::canTakeFocus(FocusDirection)

{

return GTK_WIDGET_CAN_FOCUS(m_webView);

}

void ChromeClient::repaint(const IntRect& windowRect, bool contentChanged, bool immediate, bool repaintContentOnly)

{

GdkRectangle rect = windowRect;

GdkWindow* window = GTK_WIDGET(m_webView)->window;

void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect)

{

GdkWindow* window = GTK_WIDGET(m_webView)->window;

if (!window)

return;

PlatformWidget ChromeClient::platformWindow() const

{

}

void ChromeClient::mouseDidMoveOverElement(const HitTestResult& hit, unsigned modifierFlags)

{

#if GTK_CHECK_VERSION(2,12,0)

if (toolTip.isEmpty())

else

gtk_widget_set_tooltip_text(GTK_WIDGET(m_webView), toolTip.utf8().data());

#else

void ChromeClient::runOpenPanel(Frame*, PassRefPtr<FileChooser> prpFileChooser)

{

GtkWidget* dialog = gtk_file_chooser_dialog_new(_("Upload File"),

GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(platformWindow()))),

GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,

NULL);

if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {

}

gtk_widget_destroy(dialog);

}

virtual WebCore::IntPoint screenToWindow(const WebCore::IntPoint&) const;

virtual WebCore::IntRect windowToScreen(const WebCore::IntRect&) const;

virtual PlatformWidget platformWindow() const;

virtual void mouseDidMoveOverElement(const WebCore::HitTestResult&, unsigned modifierFlags);

virtual void runOpenPanel(WebCore::Frame*, PassRefPtr<WebCore::FileChooser>);

private:

WebKitWebView* m_webView;

WebCore::KURL m_hoveredLinkURL;

return false;

}

void EditorClient::toggleContinuousSpellChecking()

{

notImplemented();

virtual bool shouldDeleteRange(WebCore::Range*);

virtual bool shouldShowDeleteInterface(WebCore::HTMLElement*);

virtual bool smartInsertDeleteEnabled();

virtual bool isContinuousSpellCheckingEnabled();

virtual void toggleContinuousSpellChecking();

virtual bool isGrammarCheckingEnabled();

#include "config.h"

#include "FrameLoaderClientGtk.h"

#include "DocumentLoader.h"

#include "FrameLoader.h"

#include "FrameView.h"

#include "FrameTree.h"

#include "JSDOMWindow.h"

#include "Language.h"

#include "MIMETypeRegistry.h"

#include "NotImplemented.h"

#include "PlatformString.h"

#include "PluginDatabase.h"

#include "JSDOMBinding.h"

#include "ScriptController.h"

#include "webkitwebview.h"

#include "webkitwebframe.h"

#include "webkitprivate.h"

#include <JavaScriptCore/APICast.h>

FrameLoaderClient::FrameLoaderClient(WebKitWebFrame* frame)

: m_frame(frame)

, m_userAgent("")

, m_pluginView(0)

, m_hasSentResponseToPlugin(false)

{

ASSERT(m_frame);

}

static String agentPlatform()

{

#ifdef GDK_WINDOWING_X11

}

}

void FrameLoaderClient::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*, unsigned long identifier, const AuthenticationChallenge&)

{

notImplemented();

void FrameLoaderClient::frameLoaderDestroyed()

{

g_object_unref(m_frame);

m_frame = 0;

delete this;

m_response = response;

}

{

ASSERT(policyFunction);

if (!policyFunction)

return;

}

{

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

}

void FrameLoaderClient::dispatchDecidePolicyForNavigationAction(FramePolicyFunction policyFunction, const NavigationAction& action, const ResourceRequest& resourceRequest, PassRefPtr<FormState>)

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);

if (response == WEBKIT_NAVIGATION_RESPONSE_IGNORE) {

(core(m_frame)->loader()->*policyFunction)(PolicyIgnore);

return;

}

}

Widget* FrameLoaderClient::createPlugin(const IntSize& pluginSize, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)

Frame* coreFrame = core(webFrame());

ASSERT(core(getViewFromFrame(webFrame())) == coreFrame->page());

coreFrame->tree()->appendChild(childFrame);

childFrame->tree()->setName(name);

childFrame->init();

// The frame's onload handler may have removed it from the document.

if (!childFrame->tree()->parent())

notImplemented();

}

void FrameLoaderClient::dispatchDidHandleOnloadEvents()

{

notImplemented();

notImplemented();

}

{

notImplemented();

}

void FrameLoaderClient::cancelPolicyCheck()

{

}

void FrameLoaderClient::dispatchDidLoadMainResource(DocumentLoader*)

return true;

}

{

}

bool FrameLoaderClient::representationExistsForURLScheme(const String&) const

Frame* FrameLoaderClient::dispatchCreatePage()

{

}

void FrameLoaderClient::dispatchUnableToImplementPolicy(const ResourceError&)

notImplemented();

}

{

notImplemented();

}

{

}

{

}

void FrameLoaderClient::transitionToCommittedForNewPage()

{

Frame* frame = core(m_frame);

ASSERT(frame);

}

}

#include "FrameLoaderClient.h"

#include "ResourceResponse.h"

#include "PluginView.h"

typedef struct _WebKitWebFrame WebKitWebFrame;

class FrameLoaderClient : public WebCore::FrameLoaderClient {

public:

FrameLoaderClient(WebKitWebFrame*);

virtual void frameLoaderDestroyed();

WebKitWebFrame* webFrame() const { return m_frame; }

virtual void detachedFromParent2();

virtual void detachedFromParent3();

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 dispatchDidFinishDocumentLoad();

virtual void dispatchDidFinishLoad();

virtual void dispatchDidFirstLayout();

virtual WebCore::Frame* dispatchCreatePage();

virtual void dispatchShow();

virtual void committedLoad(WebCore::DocumentLoader*, const char*, int);

virtual void finishedLoading(WebCore::DocumentLoader*);

virtual bool shouldGoToHistoryItem(WebCore::HistoryItem*) const;

virtual WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&);

virtual WebCore::String userAgent(const WebCore::KURL&);

virtual void transitionToCommittedForNewPage();

virtual bool canCachePage() const;

WebKitWebFrame* m_frame;

WebCore::ResourceResponse m_response;

WebCore::String m_userAgent;

// Plugin view to redirect data to

WebCore::PluginView* m_pluginView;

// close-window and destroy signals still need to be

// emitted.

WebKitWebInspector* webInspector;

m_webInspector = webInspector;

g_signal_emit_by_name(m_webInspector, "inspect-web-view", m_inspectedWebView, &m_webView);

webkit_web_inspector_set_web_view(m_webInspector, m_webView);

G_CALLBACK(notifyWebViewDestroyed), (gpointer)this);

webkit_web_view_open(m_webView, "file://"DATA_DIR"/webkit-1.0/webinspector/inspector.html");

/*

* 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

#include <webkit/webkitwebframe.h>

#include <webkit/webkitwebsettings.h>

#include <webkit/webkitwebinspector.h>

#include <webkit/webkitwebview.h>

#include <webkit/webkitwebbackforwardlist.h>

#include <webkit/webkitwebhistoryitem.h>

#include <webkit/webkitenumtypes.h>

#endif /* __WEBKIT_H__ */

/*

* 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

typedef struct _WebKitWebFrame WebKitWebFrame;

typedef struct _WebKitWebFrameClass WebKitWebFrameClass;

typedef struct _WebKitWebSettings WebKitWebSettings;

typedef struct _WebKitWebSettingsClass WebKitWebSettingsClass;

typedef struct _WebKitWebInspector WebKitWebInspector;

typedef struct _WebKitWebInspectorClass WebKitWebInspectorClass;

typedef struct _WebKitWebView WebKitWebView;

typedef struct _WebKitWebViewClass WebKitWebViewClass;

/*

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Library General Public

#include "webkitnetworkrequest.h"

extern "C" {

G_DEFINE_TYPE(WebKitNetworkRequest, webkit_network_request, G_TYPE_OBJECT);

priv->uri = g_strdup(uri);

}

G_CONST_RETURN gchar* webkit_network_request_get_uri(WebKitNetworkRequest* request)

{

g_return_val_if_fail(WEBKIT_IS_NETWORK_REQUEST(request), NULL);

struct _WebKitNetworkRequest {

GObject parent_instance;

WebKitNetworkRequestPrivate *priv;

};

struct _WebKitNetworkRequestClass {

GObjectClass parent_class;

};

WEBKIT_API GType

/*

* 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

return 0;

WebKitWebFramePrivate* priv = frame->priv;

}

WebKitWebFrame* kit(WebCore::Frame* coreFrame)

return client ? client->webView() : 0;

}

} /** end namespace WebKit */

void webkit_init()

/*

* Copyright (C) 2007, 2008 Holger Hans Peter Freyther

* 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

#include <webkit/webkitdefines.h>

#include <webkit/webkitwebview.h>

#include <webkit/webkitwebframe.h>

#include <webkit/webkitwebsettings.h>

#include <webkit/webkitwebbackforwardlist.h>

#include "BackForwardList.h"

#include "Frame.h"

#include "InspectorClientGtk.h"

#include "FrameLoaderClient.h"

#include <glib.h>

WebKitWebHistoryItem* kit(WebCore::HistoryItem*);

WebCore::BackForwardList* core(WebKitWebBackForwardList*);

}

extern "C" {

WebCore::Page* corePage;

WebKitWebSettings* webSettings;

WebKitWebInspector* webInspector;

WebKitWebFrame* mainFrame;

WebCore::String applicationNameForUserAgent;

#define WEBKIT_WEB_FRAME_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_FRAME, WebKitWebFramePrivate))

typedef struct _WebKitWebFramePrivate WebKitWebFramePrivate;

struct _WebKitWebFramePrivate {

WebKitWebView* webView;

gchar* name;

gchar* uri;

};

webkit_web_frame_init_with_web_view(WebKitWebView*, WebCore::HTMLFrameOwnerElement*);

WebKitWebHistoryItem*

webkit_web_history_item_new_with_core_item(WebCore::HistoryItem*);

void

webkit_web_inspector_set_inspected_uri(WebKitWebInspector* web_inspector, const gchar* inspected_uri);

// FIXME: Move these to webkitwebframe.h once their API has been discussed.

WEBKIT_API GSList*

WEBKIT_API gchar*

webkit_web_frame_dump_render_tree (WebKitWebFrame* frame);

WEBKIT_API gchar*

webkit_web_view_get_selected_text (WebKitWebView* web_view);

}

#endif

#include "BackForwardList.h"

#include "HistoryItem.h"

using namespace WebKit;

extern "C" {

/**

* webkit_web_back_forward_list_new_with_web_view:

*

* Creates an instance of the back forward list with a controlling #WebKitWebView

*

/**

* webkit_web_back_forward_list_go_forward:

*

* Steps forward in the back forward list

*/

/**

* webkit_web_back_forward_list_go_back:

*

* Steps backward in the back forward list

*/

/**

* webkit_web_back_forward_list_contains_item:

*

*

*/

gboolean webkit_web_back_forward_list_contains_item(WebKitWebBackForwardList* webBackForwardList, WebKitWebHistoryItem* webHistoryItem)

{

/**

* webkit_web_back_forward_list_go_to_item:

*

*/

void webkit_web_back_forward_list_go_to_item(WebKitWebBackForwardList* webBackForwardList, WebKitWebHistoryItem* webHistoryItem)

{

/**

* webkit_web_back_forward_list_get_forward_list_with_limit:

* @limit: the number of items to retrieve

*

* Returns a list of items that succeed the current item, limited by @limit

/**

* webkit_web_back_forward_list_get_back_list_with_limit:

* @limit: the number of items to retrieve

*

* Returns a list of items that precede the current item, limited by @limit

}

/**

* webkit_web_back_forward_list_get_back_item:

*

* Returns the item that precedes the current item

*

/**

* webkit_web_back_forward_list_get_current_item:

*

* Returns the current item.

*

/**

* webkit_web_back_forward_list_get_forward_item:

*

* Returns the item that succeeds the current item.

*

/**

* webkit_web_back_forward_list_get_nth_item:

* @index: the index of the item

*

* Returns the item at a given index relative to the current item.

/**

* webkit_web_back_forward_list_get_back_length:

*

* Returns the number of items that preced the current item.

*

/**

* webkit_web_back_forward_list_get_forward_length:

*

* Returns the number of items that succeed the current item.

*

/**

* webkit_web_back_forward_list_get_limit:

*

* Returns the maximum limit of the back forward list.

*

/**

* webkit_web_back_forward_list_set_limit:

* @limit: the limit to set the back forward list to

*

* Sets the maximum limit of the back forward list. If the back forward list

struct _WebKitWebBackForwardList {

GObject parent_instance;

WebKitWebBackForwardListPrivate *priv;

};

struct _WebKitWebBackForwardListClass {

GObjectClass parent_class;

};

WEBKIT_API GType

#include "webkitmarshal.h"

#include "webkitprivate.h"

#include "CString.h"

#include "FrameLoader.h"

#include "FrameLoaderClientGtk.h"

#include <JavaScriptCore/APICast.h>

using namespace WebKit;

using namespace WebCore;

using namespace std;

}

}

static void webkit_web_frame_finalize(GObject* object)

{

WebKitWebFrame* frame = WEBKIT_WEB_FRAME(object);

WebKitWebFramePrivate* priv = frame->priv;

g_free(priv->name);

g_free(priv->title);

WebKitWebViewPrivate* viewPriv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);

priv->webView = webView;

priv->coreFrame->init();

return frame;

}

{

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->webView = webView;

}

/**

return priv->name;

Frame* coreFrame = core(frame);

String string = coreFrame->tree()->name();

priv->name = g_strdup(string.utf8().data());

g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);

Frame* coreFrame = core(frame);

return kit(coreFrame->tree()->parent());

}

g_return_if_fail(WEBKIT_IS_NETWORK_REQUEST(request));

Frame* coreFrame = core(frame);

// TODO: Use the ResourceRequest carried by WebKitNetworkRequest when it is implemented.

String string = String::fromUTF8(webkit_network_request_get_uri(request));

g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));

Frame* coreFrame = core(frame);

coreFrame->loader()->stopAllLoaders();

}

g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));

Frame* coreFrame = core(frame);

coreFrame->loader()->reload();

}

g_return_val_if_fail(name, NULL);

Frame* coreFrame = core(frame);

String nameString = String::fromUTF8(name);

return kit(coreFrame->tree()->find(AtomicString(nameString)));

g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);

Frame* coreFrame = core(frame);

return toGlobalRef(coreFrame->script()->globalObject()->globalExec());

}

g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);

Frame* coreFrame = core(frame);

GSList* children = NULL;

for (Frame* child = coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {

g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);

Frame* coreFrame = core(frame);

FrameView* view = coreFrame->view();

g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);

Frame* coreFrame = core(frame);

FrameView* view = coreFrame->view();

topLevel = NULL;

Frame* coreFrame = core(frame);

PrintContext printContext(coreFrame);

GtkPrintOperation* op = gtk_print_operation_new();

GError *error = NULL;

gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(topLevel), &error);

g_object_unref(op);

#endif

}

struct _WebKitWebFrame {

GObject parent_instance;

WebKitWebFramePrivate *priv;

};

struct _WebKitWebFrameClass {

GObjectClass parent_class;

void (*_webkit_reserved1) (void);

void (*_webkit_reserved2) (void);

void (*_webkit_reserved3) (void);

#include "HistoryItem.h"

#include "PlatformString.h"

using namespace WebKit;

extern "C" {

/**

* webkit_web_history_item_get_title:

*

*/

G_CONST_RETURN gchar* webkit_web_history_item_get_title(WebKitWebHistoryItem* webHistoryItem)

{

/**

* webkit_web_history_item_get_alternate_title:

*

*

*/

G_CONST_RETURN gchar* webkit_web_history_item_get_alternate_title(WebKitWebHistoryItem* webHistoryItem)

{

/**

* webkit_web_history_item_set_alternate_title:

* @title: the alternate title for @this history item

*

*/

void webkit_web_history_item_set_alternate_title(WebKitWebHistoryItem* webHistoryItem, const gchar* title)

{

/**

* webkit_web_history_item_get_uri:

*

* Returns the URI of @this

*

*/

G_CONST_RETURN gchar* webkit_web_history_item_get_uri(WebKitWebHistoryItem* webHistoryItem)

{

/**

* webkit_web_history_item_get_original_uri:

*

*

*/

G_CONST_RETURN gchar* webkit_web_history_item_get_original_uri(WebKitWebHistoryItem* webHistoryItem)

{

/**

* webkit_web_history_item_get_last_visisted_time :

*

*

*/

gdouble webkit_web_history_item_get_last_visited_time(WebKitWebHistoryItem* webHistoryItem)

{

struct _WebKitWebHistoryItem {

GObject parent_instance;

WebKitWebHistoryItemPrivate *priv;

};

struct _WebKitWebHistoryItemClass {

GObjectClass parent_class;

};

WEBKIT_API GType

/*

* Copyright (C) 2008 Gustavo Noronha Silva

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Library General Public

#include "InspectorClientGtk.h"

#include "webkitprivate.h"

using namespace WebKit;

extern "C" {

*

* Emitted when the inspector window should be displayed. Notice

* that the window must have been created already by handling

*

* Since: 1.0.3

*/

*

* Emitted when the inspector window should be closed. You can

* destroy the window or hide it so that it can be displayed again

*

* Notice that the inspected #WebKitWebView may no longer exist

* when this signal is emitted.

*

* Notice, too, that if you decide to destroy the window,

* inspects an element.

*

* Since: 1.0.3

*

* Obtains the #WebKitWebView that is used to render the

* inspector. The #WebKitWebView instance is created by the

* that this method may return %NULL if the user hasn't inspected

* anything.

*

* Copyright (C) 2008 Christian Dywan <christian@imendio.com>

* Copyright (C) 2008 Nuanti Ltd.

* Copyright (C) 2008 Collabora Ltd.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Library General Public

#include "webkitwebsettings.h"

#include "webkitprivate.h"

extern "C" {

G_DEFINE_TYPE(WebKitWebSettings, webkit_web_settings, G_TYPE_OBJECT)

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;

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,

"default-font-size",

"Default Font Size",

"The default font size used to display text.",

flags));

g_object_class_install_property(gobject_class,

1, G_MAXINT, 5,

flags));

g_object_class_install_property(gobject_class,

PROP_AUTO_LOAD_IMAGES,

g_param_spec_boolean(

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_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;

return copy;

}

}

struct _WebKitWebSettings {

GObject parent_instance;

WebKitWebSettingsPrivate *priv;

};

/*

* Copyright (C) 2007, 2008 Christian Dywan <christian@imendio.com>

* Copyright (C) 2007 Xan Lopez <xan@gnome.org>

* Copyright (C) 2007, 2008 Alp Toker <alp@atoker.com>

* Copyright (C) 2008 Jan Alonzo <jmalonzo@unpluggable.com>

* Copyright (C) 2008 Nuanti Ltd.

* Copyright (C) 2008 Collabora Ltd.

*

#include "config.h"

#include "webkitwebview.h"

#include "webkitmarshal.h"

#include "webkitprivate.h"

#include "webkitwebinspector.h"

#include "Editor.h"

#include "EditorClientGtk.h"

#include "EventHandler.h"

#include "FocusController.h"

#include "FrameLoaderTypes.h"

#include "HitTestRequest.h"

#include "PasteboardHelper.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformWheelEvent.h"

#include "Scrollbar.h"

#include "SubstituteData.h"

#include <wtf/GOwnPtr.h>

#include <gdk/gdkkeysyms.h>

static const double defaultDPI = 96.0;

using namespace WebKit;

enum {

/* normal signals */

NAVIGATION_REQUESTED,

WINDOW_OBJECT_CLEARED,

LOAD_STARTED,

LOAD_COMMITTED,

PROP_EDITABLE,

PROP_SETTINGS,

PROP_WEB_INSPECTOR,

PROP_TRANSPARENT,

PROP_ZOOM_LEVEL,

PROP_FULL_CONTENT_ZOOM

G_DEFINE_TYPE(WebKitWebView, webkit_web_view, GTK_TYPE_CONTAINER)

static void webkit_web_view_settings_notify(WebKitWebSettings* webSettings, GParamSpec* pspec, WebKitWebView* webView);

static void webkit_web_view_context_menu_position_func(GtkMenu*, gint* x, gint* y, gboolean* pushIn, WebKitWebViewPrivate* data)

{

if (!renderer)

return FALSE;

int extraWidthToEndOfLine = 0;

InlineBox* startInlineBox;

int startCaretOffset;

start.getInlineBoxAndOffset(DOWNSTREAM, startInlineBox, startCaretOffset);

InlineBox* endInlineBox;

int endCaretOffset;

end.getInlineBoxAndOffset(UPSTREAM, endInlineBox, endCaretOffset);

IntRect firstRect;

if (startCaretRect.y() == endCaretRect.y())

case PROP_WEB_INSPECTOR:

g_value_set_object(value, webkit_web_view_get_inspector(webView));

break;

case PROP_TRANSPARENT:

g_value_set_boolean(value, webkit_web_view_get_transparent(webView));

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;

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();

if (hadj)

(*callback)(*current, callbackData);

}

{

return 0;

}

{

return WEBKIT_NAVIGATION_RESPONSE_ACCEPT;

}

frame->editor()->command("Paste").execute();

}

{

WebKitWebView* webView = WEBKIT_WEB_VIEW(object);

WebKitWebViewPrivate* priv = webView->priv;

g_object_unref(priv->horizontalAdjustment);

g_object_unref(priv->verticalAdjustment);

}

static gboolean webkit_navigation_request_handled(GSignalInvocationHint* ihint, GValue* returnAccu, const GValue* handlerReturn, gpointer dummy)

{

}

static AtkObject* webkit_web_view_get_accessible(GtkWidget* widget)

{

WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

AXObjectCache::enableAccessibility();

Frame* coreFrame = core(webView)->mainFrame();

* 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,

/**

* WebKitWebView::window-object-cleared:

* WebKitWebView::select-all:

* @web_view: the object which received the signal

*

* select the complete contents of the text view.

*

* The default bindings for this signal is Ctrl-a.

* WebKitWebView::cut-clipboard:

* @web_view: the object which received the signal

*

* cut the selection to the clipboard.

*

* The default bindings for this signal are Ctrl-x and Shift-Delete.

* WebKitWebView::copy-clipboard:

* @web_view: the object which received the signal

*

* copy the selection to the clipboard.

*

* The default bindings for this signal are Ctrl-c and Ctrl-Insert.

* WebKitWebView::paste-clipboard:

* @web_view: the object which received the signal

*

* paste the contents of the clipboard into the Web view.

*

* The default bindings for this signal are Ctrl-v and Shift-Insert.

* 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->paste_clipboard = webkit_web_view_real_paste_clipboard;

GObjectClass* objectClass = G_OBJECT_CLASS(webViewClass);

objectClass->get_property = webkit_web_view_get_property;

objectClass->set_property = webkit_web_view_set_property;

WEBKIT_TYPE_WEB_INSPECTOR,

WEBKIT_PARAM_READABLE));

g_object_class_install_property(objectClass, PROP_EDITABLE,

g_param_spec_boolean("editable",

"Editable",

g_type_class_add_private(webViewClass, sizeof(WebKitWebViewPrivate));

}

{

WebKitWebViewPrivate* priv = webView->priv;

WebKitWebSettings* webSettings = priv->webSettings;

gdouble DPI = defaultDPI;

#if GTK_CHECK_VERSION(2,10,0)

}

#endif

ASSERT(DPI > 0);

settings->setDefaultFontSize(defaultFontSize / 72.0 * DPI);

settings->setDefaultFixedFontSize(defaultMonospaceFontSize / 72.0 * DPI);

settings->setMinimumFontSize(minimumFontSize / 72.0 * DPI);

gchar* defaultEncoding, *cursiveFontFamily, *defaultFontFamily, *fantasyFontFamily, *monospaceFontFamily, *sansSerifFontFamily, *serifFontFamily, *userStylesheetUri;

gboolean autoLoadImages, autoShrinkImages, printBackgrounds, enableScripts, enablePlugins, enableDeveloperExtras, resizableTextAreas;

"default-encoding", &defaultEncoding,

"cursive-font-family", &cursiveFontFamily,

"default-font-family", &defaultFontFamily,

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();

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"))

else if (name == g_intern_string("default-monospace-font-size"))

else if (name == g_intern_string("minimum-font-size"))

else if (name == g_intern_string("minimum-logical-font-size"))

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"))

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)

return GTK_WIDGET(webView);

}

void webkit_web_view_set_settings(WebKitWebView* webView, WebKitWebSettings* webSettings)

{

g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));

/**

* webkit_web_view_get_inspector:

*

* Obtains the #WebKitWebInspector associated with the

* #WebKitWebView. Every #WebKitWebView object has a

return priv->webInspector;

}

/**

* webkit_web_view_set_maintains_back_forward_list:

* @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.

/**

* webkit_web_view_get_back_forward_list:

*

* Returns a #WebKitWebBackForwardList

*

/**

* webkit_web_view_go_to_back_forward_item:

* @item: a #WebKitWebHistoryItem*

*

* Go to the specified #WebKitWebHistoryItem

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));

}

/**

* webkit_web_view_get_transparent:

* @web_view: a #WebKitWebView

*

/*

* 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

struct _WebKitWebView {

GtkContainer parent_instance;

WebKitWebViewPrivate *priv;

};

struct _WebKitWebViewClass {

GtkContainerClass parent_class;

/*

* default handler/virtual methods

*/

WebKitNavigationResponse (* navigation_requested) (WebKitWebView *web_view,

WebKitWebFrame *frame,

WebKitNetworkRequest *request);

void (* set_scroll_adjustments) (WebKitWebView *web_view,

GtkAdjustment *hadjustment,

GtkAdjustment *vadjustment);

};

WEBKIT_API GType

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,

WEBKIT_API gboolean

webkit_web_view_search_text (WebKitWebView *web_view,

gboolean case_sensitive,

gboolean forward,

gboolean wrap);

WEBKIT_API WebKitWebInspector *

webkit_web_view_get_inspector (WebKitWebView *web_view);

WEBKIT_API gboolean

webkit_web_view_get_transparent (WebKitWebView *web_view);