/*

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

 *  Copyright (C) 2007, 2008, 2009 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 Gustavo Noronha Silva <gns@gnome.org>

 *  Copyright (C) 2008 Nuanti Ltd.

 *  Copyright (C) 2008, 2009, 2010 Collabora Ltd.

 *  Copyright (C) 2009, 2010 Igalia S.L.

 *  Copyright (C) 2009 Movial Creative Technologies Inc.

 *  Copyright (C) 2009 Bobby Powers

 *

 *  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 "webkitdownload.h"

#include "webkitenumtypes.h"

#include "webkitgeolocationpolicydecision.h"

#include "webkitmarshal.h"

#include "webkitnetworkrequest.h"

#include "webkitnetworkresponse.h"

#include "webkitprivate.h"

#include "webkitwebinspector.h"

#include "webkitwebbackforwardlist.h"

#include "webkitwebhistoryitem.h"

#include "AXObjectCache.h"

#include "AbstractDatabase.h"

#include "BackForwardList.h"

#include "Cache.h"

#include "ChromeClientGtk.h"

#include "ClipboardUtilitiesGtk.h"

#include "ContextMenuClientGtk.h"

#include "ContextMenuController.h"

#include "ContextMenu.h"

#include "Cursor.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "DragActions.h"

#include "DragClientGtk.h"

#include "DragController.h"

#include "DragData.h"

#include "EditorClientGtk.h"

#include "Editor.h"

#include "EventHandler.h"

#include "FloatQuad.h"

#include "FocusController.h"

#include "FrameLoader.h"

#include "FrameLoaderTypes.h"

#include "FrameView.h"

#include <glib/gi18n-lib.h>

#include <GOwnPtr.h>

#include <GOwnPtrGtk.h>

#include "GraphicsContext.h"

#include "GtkVersioning.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "IconDatabase.h"

#include "InspectorClientGtk.h"

#include "MouseEventWithHitTestResults.h"

#include "NotImplemented.h"

#include "PageCache.h"

#include "Pasteboard.h"

#include "PasteboardHelperGtk.h"

#include "PasteboardHelper.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformWheelEvent.h"

#include "ProgressTracker.h"

#include "RenderView.h"

#include "ResourceHandle.h"

#include "ScriptValue.h"

#include "Scrollbar.h"

#include "webkit/WebKitDOMDocumentPrivate.h"

#include <wtf/text/CString.h>

#include <gdk/gdkkeysyms.h>

/**

 * SECTION:webkitwebview

 * @short_description: The central class of the WebKitGTK+ API

 * @see_also: #WebKitWebSettings, #WebKitWebFrame

 *

 * #WebKitWebView is the central class of the WebKitGTK+ API. It is a

 * #GtkWidget implementing the scrolling interface which means you can

 * embed in a #GtkScrolledWindow. It is responsible for managing the

 * drawing of the content, forwarding of events. You can load any URI

 * into the #WebKitWebView or any kind of data string. With #WebKitWebSettings

 * you can control various aspects of the rendering and loading of the content.

 * Each #WebKitWebView has exactly one #WebKitWebFrame as main frame. A

 * #WebKitWebFrame can have n children.

 *

 * <programlisting>

 * /<!-- -->* Create the widgets *<!-- -->/

 * GtkWidget *main_window = gtk_window_new (GTK_WIDGET_TOPLEVEL);

 * GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);

 * GtkWidget *web_view = webkit_web_view_new ();

 *

 * /<!-- -->* Place the WebKitWebView in the GtkScrolledWindow *<!-- -->/

 * gtk_container_add (GTK_CONTAINER (scrolled_window), web_view);

 * gtk_container_add (GTK_CONTAINER (main_window), scrolled_window);

 *

 * /<!-- -->* Open a webpage *<!-- -->/

 * webkit_web_view_load_uri (WEBKIT_WEB_VIEW (web_view), "http://www.gnome.org");

 *

 * /<!-- -->* Show the result *<!-- -->/

 * gtk_window_set_default_size (GTK_WINDOW (main_window), 800, 600);

 * gtk_widget_show_all (main_window);

 * </programlisting>

 */

static const double defaultDPI = 96.0;

static WebKitCacheModel cacheModel;

static IntPoint globalPointForClientPoint(GdkWindow* window, const IntPoint& clientPoint);

using namespace WebKit;

using namespace WebCore;

enum {

    /* normal signals */

    NAVIGATION_REQUESTED,

    NEW_WINDOW_POLICY_DECISION_REQUESTED,

    NAVIGATION_POLICY_DECISION_REQUESTED,

    MIME_TYPE_POLICY_DECISION_REQUESTED,

    CREATE_WEB_VIEW,

    WEB_VIEW_READY,

    WINDOW_OBJECT_CLEARED,

    LOAD_STARTED,

    LOAD_COMMITTED,

    LOAD_PROGRESS_CHANGED,

    LOAD_ERROR,

    LOAD_FINISHED,

    TITLE_CHANGED,

    HOVERING_OVER_LINK,

    POPULATE_POPUP,

    STATUS_BAR_TEXT_CHANGED,

    ICON_LOADED,

    SELECTION_CHANGED,

    CONSOLE_MESSAGE,

    SCRIPT_ALERT,

    SCRIPT_CONFIRM,

    SCRIPT_PROMPT,

    SELECT_ALL,

    COPY_CLIPBOARD,

    PASTE_CLIPBOARD,

    CUT_CLIPBOARD,

    DOWNLOAD_REQUESTED,

    MOVE_CURSOR,

    PRINT_REQUESTED,

    PLUGIN_WIDGET,

    CLOSE_WEB_VIEW,

    UNDO,

    REDO,

    DATABASE_QUOTA_EXCEEDED,

    RESOURCE_REQUEST_STARTING,

    DOCUMENT_LOAD_FINISHED,

    GEOLOCATION_POLICY_DECISION_REQUESTED,

    GEOLOCATION_POLICY_DECISION_CANCELLED,

    ONLOAD_EVENT,

    LAST_SIGNAL

};

enum {

    PROP_0,

    PROP_TITLE,

    PROP_URI,

    PROP_COPY_TARGET_LIST,

    PROP_PASTE_TARGET_LIST,

    PROP_EDITABLE,

    PROP_SETTINGS,

    PROP_WEB_INSPECTOR,

    PROP_WINDOW_FEATURES,

    PROP_TRANSPARENT,

    PROP_ZOOM_LEVEL,

    PROP_FULL_CONTENT_ZOOM,

    PROP_LOAD_STATUS,

    PROP_PROGRESS,

    PROP_ENCODING,

    PROP_CUSTOM_ENCODING,

    PROP_ICON_URI,

    PROP_IM_CONTEXT

};

static guint webkit_web_view_signals[LAST_SIGNAL] = { 0, };

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_set_window_features(WebKitWebView* webView, WebKitWebWindowFeatures* webWindowFeatures);

static GtkIMContext* webkit_web_view_get_im_context(WebKitWebView*);

static void destroy_menu_cb(GtkObject* object, gpointer data)

{

    WebKitWebView* webView = WEBKIT_WEB_VIEW(data);

    WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);

    g_object_unref(priv->currentMenu);

    priv->currentMenu = NULL;

}

static void PopupMenuPositionFunc(GtkMenu* menu, gint *x, gint *y, gboolean *pushIn, gpointer userData)

{

    WebKitWebView* view = WEBKIT_WEB_VIEW(userData);

    WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(view);

    GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET(view));

    GtkRequisition menuSize;

    gtk_widget_size_request(GTK_WIDGET(menu), &menuSize);

    *x = priv->lastPopupXPosition;

    if ((*x + menuSize.width) >= gdk_screen_get_width(screen))

      *x -= menuSize.width;

    *y = priv->lastPopupYPosition;

    if ((*y + menuSize.height) >= gdk_screen_get_height(screen))

      *y -= menuSize.height;

    *pushIn = FALSE;

}

static gboolean webkit_web_view_forward_context_menu_event(WebKitWebView* webView, const PlatformMouseEvent& event)

{

    Page* page = core(webView);

    page->contextMenuController()->clearContextMenu();

    Frame* focusedFrame;

    Frame* mainFrame = page->mainFrame();

    gboolean mousePressEventResult = FALSE;

    if (!mainFrame->view())

        return FALSE;

    mainFrame->view()->setCursor(pointerCursor());

    if (page->frameCount()) {

        HitTestRequest request(HitTestRequest::Active);

        IntPoint point = mainFrame->view()->windowToContents(event.pos());

        MouseEventWithHitTestResults mev = mainFrame->document()->prepareMouseEvent(request, point, event);

        Frame* targetFrame = EventHandler::subframeForTargetNode(mev.targetNode());

        if (!targetFrame)

            targetFrame = mainFrame;

        focusedFrame = page->focusController()->focusedOrMainFrame();

        if (targetFrame != focusedFrame) {

            page->focusController()->setFocusedFrame(targetFrame);

            focusedFrame = targetFrame;

        }

    } else

        focusedFrame = mainFrame;

    if (focusedFrame->view() && focusedFrame->eventHandler()->handleMousePressEvent(event))

        mousePressEventResult = TRUE;

    bool handledEvent = focusedFrame->eventHandler()->sendContextMenuEvent(event);

    if (!handledEvent)

        return FALSE;

    // If coreMenu is NULL, this means WebCore decided to not create

    // the default context menu; this may happen when the page is

    // handling the right-click for reasons other than the context menu.

    ContextMenu* coreMenu = page->contextMenuController()->contextMenu();

    if (!coreMenu)

        return mousePressEventResult;

    // If we reach here, it's because WebCore is going to show the

    // default context menu. We check our setting to figure out

    // whether we want it or not.

    WebKitWebSettings* settings = webkit_web_view_get_settings(webView);

    gboolean enableDefaultContextMenu;

    g_object_get(settings, "enable-default-context-menu", &enableDefaultContextMenu, NULL);

    if (!enableDefaultContextMenu)

        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->currentMenu = GTK_MENU(g_object_ref(menu));

    priv->lastPopupXPosition = event.globalX();

    priv->lastPopupYPosition = event.globalY();

    g_signal_connect(menu, "destroy",

                     G_CALLBACK(destroy_menu_cb),

                     NULL);

    gtk_menu_popup(menu, NULL, NULL,

                   &PopupMenuPositionFunc,

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

    Frame* frame = page->focusController()->focusedOrMainFrame();

    FrameView* view = frame->view();

    if (!view)

        return FALSE;    

    Position start = frame->selection()->selection().start();

    Position end = frame->selection()->selection().end();

    int rightAligned = FALSE;

    IntPoint location;

    if (!start.node() || !end.node()

        || (frame->selection()->selection().isCaret() && !frame->selection()->selection().isContentEditable()))

        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:],

        // now Frame::firstRectForRange(), which perhaps this should call).

        int extraWidthToEndOfLine = 0;

        InlineBox* startInlineBox;

        int startCaretOffset;

        start.getInlineBoxAndOffset(DOWNSTREAM, startInlineBox, startCaretOffset);

        IntRect startCaretRect = renderer->localCaretRect(startInlineBox, startCaretOffset, &extraWidthToEndOfLine);

        if (startCaretRect != IntRect())

            startCaretRect = renderer->localToAbsoluteQuad(FloatRect(startCaretRect)).enclosingBoundingBox();

        InlineBox* endInlineBox;

        int endCaretOffset;

        end.getInlineBoxAndOffset(UPSTREAM, endInlineBox, endCaretOffset);

        IntRect endCaretRect = renderer->localCaretRect(endInlineBox, endCaretOffset);

        if (endCaretRect != IntRect())

            endCaretRect = renderer->localToAbsoluteQuad(FloatRect(endCaretRect)).enclosingBoundingBox();

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

    }

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

    if (location.y() < 0)

        location.setY(contextMenuMargin);

    else if (location.y() > view->height())

        location.setY(view->height() - contextMenuMargin);

    if (location.x() < 0)

        location.setX(contextMenuMargin);

    else if (location.x() > view->width())

        location.setX(view->width() - contextMenuMargin);

    IntPoint global(globalPointForClientPoint(gtk_widget_get_window(widget), location));

    PlatformMouseEvent event(location, global, RightButton, 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_TITLE:

        g_value_set_string(value, webkit_web_view_get_title(webView));

        break;

    case PROP_URI:

        g_value_set_string(value, webkit_web_view_get_uri(webView));

        break;

    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_WEB_INSPECTOR:

        g_value_set_object(value, webkit_web_view_get_inspector(webView));

        break;

    case PROP_WINDOW_FEATURES:

        g_value_set_object(value, webkit_web_view_get_window_features(webView));

        break;

    case PROP_TRANSPARENT:

        g_value_set_boolean(value, webkit_web_view_get_transparent(webView));

        break;

    case PROP_ZOOM_LEVEL:

        g_value_set_float(value, webkit_web_view_get_zoom_level(webView));

        break;

    case PROP_FULL_CONTENT_ZOOM:

        g_value_set_boolean(value, webkit_web_view_get_full_content_zoom(webView));

        break;

    case PROP_ENCODING:

        g_value_set_string(value, webkit_web_view_get_encoding(webView));

        break;

    case PROP_CUSTOM_ENCODING:

        g_value_set_string(value, webkit_web_view_get_custom_encoding(webView));

        break;

    case PROP_LOAD_STATUS:

        g_value_set_enum(value, webkit_web_view_get_load_status(webView));

        break;

    case PROP_PROGRESS:

        g_value_set_double(value, webkit_web_view_get_progress(webView));

        break;

    case PROP_ICON_URI:

        g_value_set_string(value, webkit_web_view_get_icon_uri(webView));

        break;

    case PROP_IM_CONTEXT:

        g_value_set_object(value, webkit_web_view_get_im_context(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_WINDOW_FEATURES:

        webkit_web_view_set_window_features(webView, WEBKIT_WEB_WINDOW_FEATURES(g_value_get_object(value)));

        break;

    case PROP_TRANSPARENT:

        webkit_web_view_set_transparent(webView, g_value_get_boolean(value));

        break;

    case PROP_ZOOM_LEVEL:

        webkit_web_view_set_zoom_level(webView, g_value_get_float(value));

        break;

    case PROP_FULL_CONTENT_ZOOM:

        webkit_web_view_set_full_content_zoom(webView, g_value_get_boolean(value));

        break;

    case PROP_CUSTOM_ENCODING:

        webkit_web_view_set_custom_encoding(webView, g_value_get_string(value));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static bool shouldCoalesce(GdkRectangle rect, GdkRectangle* rects, int count)

{

    const int cRectThreshold = 10;

    const float cWastedSpaceThreshold = 0.75f;

    bool useUnionedRect = (count <= 1) || (count > cRectThreshold);

    if (!useUnionedRect) {

        // Attempt to guess whether or not we should use the unioned rect or the individual rects.

        // We do this by computing the percentage of "wasted space" in the union.  If that wasted space

        // is too large, then we will do individual rect painting instead.

        float unionPixels = (rect.width * rect.height);

        float singlePixels = 0;

        for (int i = 0; i < count; ++i)

            singlePixels += rects[i].width * rects[i].height;

        float wastedSpace = 1 - (singlePixels / unionPixels);

        if (wastedSpace <= cWastedSpaceThreshold)

            useUnionedRect = true;

    }

    return useUnionedRect;

}

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

    if (frame->contentRenderer() && frame->view()) {

        frame->view()->layoutIfNeededRecursive();

        cairo_t* cr = gdk_cairo_create(event->window);

        GraphicsContext ctx(cr);

        cairo_destroy(cr);

        ctx.setGdkExposeEvent(event);

        int rectCount;

#ifdef GTK_API_VERSION_2

        GOwnPtr<GdkRectangle> rects;

        gdk_region_get_rectangles(event->region, &rects.outPtr(), &rectCount);

#else

        rectCount = cairo_region_num_rectangles(event->region);

        GOwnPtr<GdkRectangle> rects(g_new(GdkRectangle, rectCount));

        for (int i = 0; i < rectCount; i++)