1 /*

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

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

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

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

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

     7  *  Copyright (C) 2008 Gustavo Noronha Silva <gns@gnome.org>

     8  *  Copyright (C) 2008 Nuanti Ltd.

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

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

    11  *  Copyright (C) 2009 Movial Creative Technologies Inc.

    12  *  Copyright (C) 2009 Bobby Powers

    13  *

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

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

    16  *  License as published by the Free Software Foundation; either

    17  *  version 2 of the License, or (at your option) any later version.

    18  *

    19  *  This library is distributed in the hope that it will be useful,

    20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    22  *  Lesser General Public License for more details.

    23  *

    24  *  You should have received a copy of the GNU Lesser General Public

    25  *  License along with this library; if not, write to the Free Software

    26  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    27  */

    28 

    29 #include "config.h"

    30 #include "webkitwebview.h"

    31 

    32 #include "webkitdownload.h"

    33 #include "webkitenumtypes.h"

    34 #include "webkitgeolocationpolicydecision.h"

    35 #include "webkitmarshal.h"

    36 #include "webkitnetworkrequest.h"

    37 #include "webkitnetworkresponse.h"

    38 #include "webkitprivate.h"

    39 #include "webkitwebinspector.h"

    40 #include "webkitwebbackforwardlist.h"

    41 #include "webkitwebhistoryitem.h"

    42 

    43 #include "AXObjectCache.h"

    44 #include "AbstractDatabase.h"

    45 #include "BackForwardList.h"

    46 #include "Cache.h"

    47 #include "ChromeClientGtk.h"

    48 #include "ClipboardUtilitiesGtk.h"

    49 #include "ContextMenuClientGtk.h"

    50 #include "ContextMenuController.h"

    51 #include "ContextMenu.h"

    52 #include "Cursor.h"

    53 #include "Document.h"

    54 #include "DocumentLoader.h"

    55 #include "DragActions.h"

    56 #include "DragClientGtk.h"

    57 #include "DragController.h"

    58 #include "DragData.h"

    59 #include "EditorClientGtk.h"

    60 #include "Editor.h"

    61 #include "EventHandler.h"

    62 #include "FloatQuad.h"

    63 #include "FocusController.h"

    64 #include "FrameLoader.h"

    65 #include "FrameLoaderTypes.h"

    66 #include "FrameView.h"

    67 #include <glib/gi18n-lib.h>

    68 #include <GOwnPtr.h>

    69 #include <GOwnPtrGtk.h>

    70 #include "GraphicsContext.h"

    71 #include "GtkVersioning.h"

    72 #include "HitTestRequest.h"

    73 #include "HitTestResult.h"

    74 #include "IconDatabase.h"

    75 #include "InspectorClientGtk.h"

    76 #include "MouseEventWithHitTestResults.h"

    77 #include "NotImplemented.h"

    78 #include "PageCache.h"

    79 #include "Pasteboard.h"

    80 #include "PasteboardHelperGtk.h"

    81 #include "PasteboardHelper.h"

    82 #include "PlatformKeyboardEvent.h"

    83 #include "PlatformWheelEvent.h"

    84 #include "ProgressTracker.h"

    85 #include "RenderView.h"

    86 #include "ResourceHandle.h"

    87 #include "ScriptValue.h"

    88 #include "Scrollbar.h"

    89 #include "webkit/WebKitDOMDocumentPrivate.h"

    90 #include <wtf/text/CString.h>

    91 

    92 #include <gdk/gdkkeysyms.h>

    93 

    94 /**

    95  * SECTION:webkitwebview

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

    97  * @see_also: #WebKitWebSettings, #WebKitWebFrame

    98  *

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

   100  * #GtkWidget implementing the scrolling interface which means you can

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

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

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

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

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

   106  * #WebKitWebFrame can have n children.

   107  *

   108  * <programlisting>

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

   110  * GtkWidget *main_window = gtk_window_new (GTK_WIDGET_TOPLEVEL);

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

   112  * GtkWidget *web_view = webkit_web_view_new ();

   113  *

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

   115  * gtk_container_add (GTK_CONTAINER (scrolled_window), web_view);

   116  * gtk_container_add (GTK_CONTAINER (main_window), scrolled_window);

   117  *

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

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

   120  *

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

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

   123  * gtk_widget_show_all (main_window);

   124  * </programlisting>

   125  */

   126 

   127 static const double defaultDPI = 96.0;

   128 static WebKitCacheModel cacheModel;

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

   130 

   131 using namespace WebKit;

   132 using namespace WebCore;

   133 

   134 enum {

   135     /* normal signals */

   136     NAVIGATION_REQUESTED,

   137     NEW_WINDOW_POLICY_DECISION_REQUESTED,

   138     NAVIGATION_POLICY_DECISION_REQUESTED,

   139     MIME_TYPE_POLICY_DECISION_REQUESTED,

   140     CREATE_WEB_VIEW,

   141     WEB_VIEW_READY,

   142     WINDOW_OBJECT_CLEARED,

   143     LOAD_STARTED,

   144     LOAD_COMMITTED,

   145     LOAD_PROGRESS_CHANGED,

   146     LOAD_ERROR,

   147     LOAD_FINISHED,

   148     TITLE_CHANGED,

   149     HOVERING_OVER_LINK,

   150     POPULATE_POPUP,

   151     STATUS_BAR_TEXT_CHANGED,

   152     ICON_LOADED,

   153     SELECTION_CHANGED,

   154     CONSOLE_MESSAGE,

   155     SCRIPT_ALERT,

   156     SCRIPT_CONFIRM,

   157     SCRIPT_PROMPT,

   158     SELECT_ALL,

   159     COPY_CLIPBOARD,

   160     PASTE_CLIPBOARD,

   161     CUT_CLIPBOARD,

   162     DOWNLOAD_REQUESTED,

   163     MOVE_CURSOR,

   164     PRINT_REQUESTED,

   165     PLUGIN_WIDGET,

   166     CLOSE_WEB_VIEW,

   167     UNDO,

   168     REDO,

   169     DATABASE_QUOTA_EXCEEDED,

   170     RESOURCE_REQUEST_STARTING,

   171     DOCUMENT_LOAD_FINISHED,

   172     GEOLOCATION_POLICY_DECISION_REQUESTED,

   173     GEOLOCATION_POLICY_DECISION_CANCELLED,

   174     ONLOAD_EVENT,

   175     LAST_SIGNAL

   176 };

   177 

   178 enum {

   179     PROP_0,

   180 

   181     PROP_TITLE,

   182     PROP_URI,

   183     PROP_COPY_TARGET_LIST,

   184     PROP_PASTE_TARGET_LIST,

   185     PROP_EDITABLE,

   186     PROP_SETTINGS,

   187     PROP_WEB_INSPECTOR,

   188     PROP_WINDOW_FEATURES,

   189     PROP_TRANSPARENT,

   190     PROP_ZOOM_LEVEL,

   191     PROP_FULL_CONTENT_ZOOM,

   192     PROP_LOAD_STATUS,

   193     PROP_PROGRESS,

   194     PROP_ENCODING,

   195     PROP_CUSTOM_ENCODING,

   196     PROP_ICON_URI,

   197     PROP_IM_CONTEXT

   198 };

   199 

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

   201 

   202 G_DEFINE_TYPE(WebKitWebView, webkit_web_view, GTK_TYPE_CONTAINER)

   203 

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

   205 static void webkit_web_view_set_window_features(WebKitWebView* webView, WebKitWebWindowFeatures* webWindowFeatures);

   206 

   207 static GtkIMContext* webkit_web_view_get_im_context(WebKitWebView*);

   208 

   209 static void destroy_menu_cb(GtkObject* object, gpointer data)

   210 {

   211     WebKitWebView* webView = WEBKIT_WEB_VIEW(data);

   212     WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);

   213 

   214     g_object_unref(priv->currentMenu);

   215     priv->currentMenu = NULL;

   216 }

   217 

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

   219 {

   220     WebKitWebView* view = WEBKIT_WEB_VIEW(userData);

   221     WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(view);

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

   223     GtkRequisition menuSize;

   224 

   225     gtk_widget_size_request(GTK_WIDGET(menu), &menuSize);

   226 

   227     *x = priv->lastPopupXPosition;

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

   229       *x -= menuSize.width;

   230 

   231     *y = priv->lastPopupYPosition;

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

   233       *y -= menuSize.height;

   234 

   235     *pushIn = FALSE;

   236 }

   237 

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

   239 {

   240     Page* page = core(webView);

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

   242     Frame* focusedFrame;

   243     Frame* mainFrame = page->mainFrame();

   244     gboolean mousePressEventResult = FALSE;

   245 

   246     if (!mainFrame->view())

   247         return FALSE;

   248 

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

   250     if (page->frameCount()) {

   251         HitTestRequest request(HitTestRequest::Active);

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

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

   254 

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

   256         if (!targetFrame)

   257             targetFrame = mainFrame;

   258 

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

   260         if (targetFrame != focusedFrame) {

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

   262             focusedFrame = targetFrame;

   263         }

   264     } else

   265         focusedFrame = mainFrame;

   266 

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

   268         mousePressEventResult = TRUE;

   269 

   270 

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

   272     if (!handledEvent)

   273         return FALSE;

   274 

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

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

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

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

   279     if (!coreMenu)

   280         return mousePressEventResult;

   281 

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

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

   284     // whether we want it or not.

   285     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);

   286     gboolean enableDefaultContextMenu;

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

   288 

   289     if (!enableDefaultContextMenu)

   290         return FALSE;

   291 

   292     GtkMenu* menu = GTK_MENU(coreMenu->platformDescription());

   293     if (!menu)

   294         return FALSE;

   295 

   296     g_signal_emit(webView, webkit_web_view_signals[POPULATE_POPUP], 0, menu);

   297 

   298     GList* items = gtk_container_get_children(GTK_CONTAINER(menu));

   299     bool empty = !g_list_nth(items, 0);

   300     g_list_free(items);

   301     if (empty)

   302         return FALSE;

   303 

   304     WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView);

   305     priv->currentMenu = GTK_MENU(g_object_ref(menu));

   306     priv->lastPopupXPosition = event.globalX();

   307     priv->lastPopupYPosition = event.globalY();

   308 

   309     g_signal_connect(menu, "destroy",

   310                      G_CALLBACK(destroy_menu_cb),

   311                      NULL);

   312 

   313     gtk_menu_popup(menu, NULL, NULL,

   314                    &PopupMenuPositionFunc,

   315                    webView, event.button() + 1, gtk_get_current_event_time());

   316     return TRUE;

   317 }

   318 

   319 static gboolean webkit_web_view_popup_menu_handler(GtkWidget* widget)

   320 {

   321     static const int contextMenuMargin = 1;

   322 

   323     // The context menu event was generated from the keyboard, so show the context menu by the current selection.

   324     Page* page = core(WEBKIT_WEB_VIEW(widget));

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

   326     FrameView* view = frame->view();

   327     if (!view)

   328         return FALSE;    

   329 

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

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

   332 

   333     int rightAligned = FALSE;

   334     IntPoint location;

   335 

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

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

   338         location = IntPoint(rightAligned ? view->contentsWidth() - contextMenuMargin : contextMenuMargin, contextMenuMargin);

   339     else {

   340         RenderObject* renderer = start.node()->renderer();

   341         if (!renderer)

   342             return FALSE;

   343 

   344         // Calculate the rect of the first line of the selection (cribbed from -[WebCoreFrameBridge firstRectForDOMRange:],

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

   346         int extraWidthToEndOfLine = 0;

   347 

   348         InlineBox* startInlineBox;

   349         int startCaretOffset;

   350         start.getInlineBoxAndOffset(DOWNSTREAM, startInlineBox, startCaretOffset);

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

   352         if (startCaretRect != IntRect())

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

   354 

   355         InlineBox* endInlineBox;

   356         int endCaretOffset;

   357         end.getInlineBoxAndOffset(UPSTREAM, endInlineBox, endCaretOffset);

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

   359         if (endCaretRect != IntRect())

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

   361 

   362         IntRect firstRect;

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

   364             firstRect = IntRect(MIN(startCaretRect.x(), endCaretRect.x()),

   365                                 startCaretRect.y(),

   366                                 abs(endCaretRect.x() - startCaretRect.x()),

   367                                 MAX(startCaretRect.height(), endCaretRect.height()));

   368         else

   369             firstRect = IntRect(startCaretRect.x(),

   370                                 startCaretRect.y(),

   371                                 startCaretRect.width() + extraWidthToEndOfLine,

   372                                 startCaretRect.height());

   373 

   374         location = IntPoint(rightAligned ? firstRect.right() : firstRect.x(), firstRect.bottom());

   375     }

   376 

   377     // FIXME: The IntSize(0, -1) is a hack to get the hit-testing to result in the selected element.

   378     // Ideally we'd have the position of a context menu event be separate from its target node.

   379     location = view->contentsToWindow(location) + IntSize(0, -1);

   380     if (location.y() < 0)

   381         location.setY(contextMenuMargin);

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

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

   384     if (location.x() < 0)

   385         location.setX(contextMenuMargin);

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

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

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

   389 

   390     PlatformMouseEvent event(location, global, RightButton, MouseEventPressed, 0, false, false, false, false, gtk_get_current_event_time());

   391 

   392     return webkit_web_view_forward_context_menu_event(WEBKIT_WEB_VIEW(widget), event);

   393 }

   394 

   395 static void webkit_web_view_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)

   396 {

   397     WebKitWebView* webView = WEBKIT_WEB_VIEW(object);

   398 

   399     switch(prop_id) {

   400     case PROP_TITLE:

   401         g_value_set_string(value, webkit_web_view_get_title(webView));

   402         break;

   403     case PROP_URI:

   404         g_value_set_string(value, webkit_web_view_get_uri(webView));

   405         break;

   406     case PROP_COPY_TARGET_LIST:

   407         g_value_set_boxed(value, webkit_web_view_get_copy_target_list(webView));

   408         break;

   409     case PROP_PASTE_TARGET_LIST:

   410         g_value_set_boxed(value, webkit_web_view_get_paste_target_list(webView));

   411         break;

   412     case PROP_EDITABLE:

   413         g_value_set_boolean(value, webkit_web_view_get_editable(webView));

   414         break;

   415     case PROP_SETTINGS:

   416         g_value_set_object(value, webkit_web_view_get_settings(webView));

   417         break;

   418     case PROP_WEB_INSPECTOR:

   419         g_value_set_object(value, webkit_web_view_get_inspector(webView));

   420         break;

   421     case PROP_WINDOW_FEATURES:

   422         g_value_set_object(value, webkit_web_view_get_window_features(webView));

   423         break;

   424     case PROP_TRANSPARENT:

   425         g_value_set_boolean(value, webkit_web_view_get_transparent(webView));

   426         break;

   427     case PROP_ZOOM_LEVEL:

   428         g_value_set_float(value, webkit_web_view_get_zoom_level(webView));

   429         break;

   430     case PROP_FULL_CONTENT_ZOOM:

   431         g_value_set_boolean(value, webkit_web_view_get_full_content_zoom(webView));

   432         break;

   433     case PROP_ENCODING:

   434         g_value_set_string(value, webkit_web_view_get_encoding(webView));

   435         break;

   436     case PROP_CUSTOM_ENCODING:

   437         g_value_set_string(value, webkit_web_view_get_custom_encoding(webView));

   438         break;

   439     case PROP_LOAD_STATUS:

   440         g_value_set_enum(value, webkit_web_view_get_load_status(webView));

   441         break;

   442     case PROP_PROGRESS:

   443         g_value_set_double(value, webkit_web_view_get_progress(webView));

   444         break;

   445     case PROP_ICON_URI:

   446         g_value_set_string(value, webkit_web_view_get_icon_uri(webView));

   447         break;

   448     case PROP_IM_CONTEXT:

   449         g_value_set_object(value, webkit_web_view_get_im_context(webView));

   450         break;

   451     default:

   452         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

   453     }

   454 }

   455 

   456 static void webkit_web_view_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec *pspec)

   457 {

   458     WebKitWebView* webView = WEBKIT_WEB_VIEW(object);

   459 

   460     switch(prop_id) {

   461     case PROP_EDITABLE:

   462         webkit_web_view_set_editable(webView, g_value_get_boolean(value));

   463         break;

   464     case PROP_SETTINGS:

   465         webkit_web_view_set_settings(webView, WEBKIT_WEB_SETTINGS(g_value_get_object(value)));

   466         break;

   467     case PROP_WINDOW_FEATURES:

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

   469         break;

   470     case PROP_TRANSPARENT:

   471         webkit_web_view_set_transparent(webView, g_value_get_boolean(value));

   472         break;

   473     case PROP_ZOOM_LEVEL:

   474         webkit_web_view_set_zoom_level(webView, g_value_get_float(value));

   475         break;

   476     case PROP_FULL_CONTENT_ZOOM:

   477         webkit_web_view_set_full_content_zoom(webView, g_value_get_boolean(value));

   478         break;

   479     case PROP_CUSTOM_ENCODING:

   480         webkit_web_view_set_custom_encoding(webView, g_value_get_string(value));

   481         break;

   482     default:

   483         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

   484     }

   485 }

   486 

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

   488 {

   489     const int cRectThreshold = 10;

   490     const float cWastedSpaceThreshold = 0.75f;

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

   492     if (!useUnionedRect) {

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

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

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

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

   497         float singlePixels = 0;

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

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

   500         float wastedSpace = 1 - (singlePixels / unionPixels);

   501         if (wastedSpace <= cWastedSpaceThreshold)

   502             useUnionedRect = true;

   503     }

   504     return useUnionedRect;

   505 }

   506 

   507 static gboolean webkit_web_view_expose_event(GtkWidget* widget, GdkEventExpose* event)

   508 {

   509     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   510     WebKitWebViewPrivate* priv = webView->priv;

   511 

   512     Frame* frame = core(webView)->mainFrame();

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

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

   515 

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

   517         GraphicsContext ctx(cr);

   518         cairo_destroy(cr);

   519         ctx.setGdkExposeEvent(event);

   520 

   521         int rectCount;

   522 #ifdef GTK_API_VERSION_2

   523         GOwnPtr<GdkRectangle> rects;

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

   525 #else

   526         rectCount = cairo_region_num_rectangles(event->region);

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

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

   529             cairo_region_get_rectangle(event->region, i, rects.get()+i);

   530 #endif

   531         // Avoid recursing into the render tree excessively

   532         bool coalesce = shouldCoalesce(event->area, rects.get(), rectCount);

   533 

   534         if (coalesce) {

   535             IntRect rect = event->area;

   536             ctx.clip(rect);

   537             if (priv->transparent)

   538                 ctx.clearRect(rect);

   539             frame->view()->paint(&ctx, rect);

   540         } else {

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

   542                 IntRect rect = rects.get()[i];

   543                 ctx.save();

   544                 ctx.clip(rect);

   545                 if (priv->transparent)

   546                     ctx.clearRect(rect);

   547                 frame->view()->paint(&ctx, rect);

   548                 ctx.restore();

   549             }

   550         }

   551     }

   552 

   553     return FALSE;

   554 }

   555 

   556 static gboolean webkit_web_view_key_press_event(GtkWidget* widget, GdkEventKey* event)

   557 {

   558     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   559 

   560     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

   561     PlatformKeyboardEvent keyboardEvent(event);

   562 

   563     if (!frame->view())

   564         return FALSE;

   565 

   566     if (frame->eventHandler()->keyEvent(keyboardEvent))

   567         return TRUE;

   568 

   569     /* Chain up to our parent class for binding activation */

   570     return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->key_press_event(widget, event);

   571 }

   572 

   573 static gboolean webkit_web_view_key_release_event(GtkWidget* widget, GdkEventKey* event)

   574 {

   575     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   576 

   577     // GTK+ IM contexts often require us to filter key release events, which

   578     // WebCore does not do by default, so we filter the event here. We only block

   579     // the event if we don't have a pending composition, because that means we

   580     // are using a context like 'simple' which marks every keystroke as filtered.

   581     WebKit::EditorClient* client = static_cast<WebKit::EditorClient*>(core(webView)->editorClient());

   582     if (gtk_im_context_filter_keypress(webView->priv->imContext, event) && !client->hasPendingComposition())

   583         return TRUE;

   584 

   585     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

   586     if (!frame->view())

   587         return FALSE;

   588 

   589     PlatformKeyboardEvent keyboardEvent(event);

   590     if (frame->eventHandler()->keyEvent(keyboardEvent))

   591         return TRUE;

   592 

   593     /* Chain up to our parent class for binding activation */

   594     return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->key_release_event(widget, event);

   595 }

   596 

   597 static guint32 getEventTime(GdkEvent* event)

   598 {

   599     guint32 time = gdk_event_get_time(event);

   600     if (time)

   601         return time;

   602 

   603     // Real events always have a non-zero time, but events synthesized

   604     // by the DRT do not and we must calculate a time manually. This time

   605     // is not calculated in the DRT, because GTK+ does not work well with

   606     // anything other than GDK_CURRENT_TIME on synthesized events.

   607     GTimeVal timeValue;

   608     g_get_current_time(&timeValue);

   609     return (timeValue.tv_sec * 1000) + (timeValue.tv_usec / 1000);

   610 } 

   611 

   612 static gboolean webkit_web_view_button_press_event(GtkWidget* widget, GdkEventButton* event)

   613 {

   614     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   615     WebKitWebViewPrivate* priv = webView->priv;

   616 

   617     // FIXME: need to keep track of subframe focus for key events

   618     gtk_widget_grab_focus(widget);

   619 

   620     // For double and triple clicks GDK sends both a normal button press event

   621     // and a specific type (like GDK_2BUTTON_PRESS). If we detect a special press

   622     // coming up, ignore this event as it certainly generated the double or triple

   623     // click. The consequence of not eating this event is two DOM button press events

   624     // are generated.

   625     GOwnPtr<GdkEvent> nextEvent(gdk_event_peek());

   626     if (nextEvent && (nextEvent->any.type == GDK_2BUTTON_PRESS || nextEvent->any.type == GDK_3BUTTON_PRESS))

   627         return TRUE;

   628 

   629     gint doubleClickDistance = 250;

   630     gint doubleClickTime = 5;

   631     GtkSettings* settings = gtk_settings_get_for_screen(gdk_drawable_get_screen(gtk_widget_get_window(widget)));

   632     g_object_get(settings, 

   633         "gtk-double-click-distance", &doubleClickDistance,

   634         "gtk-double-click-time", &doubleClickTime, NULL);

   635 

   636     // GTK+ only counts up to triple clicks, but WebCore wants to know about

   637     // quadruple clicks, quintuple clicks, ad infinitum. Here, we replicate the

   638     // GDK logic for counting clicks.

   639     guint32 eventTime = getEventTime(reinterpret_cast<GdkEvent*>(event));

   640     if ((event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)

   641         || ((abs(event->x - priv->previousClickPoint->x()) < doubleClickDistance)

   642             && (abs(event->y - priv->previousClickPoint->y()) < doubleClickDistance)

   643             && (eventTime - priv->previousClickTime < static_cast<guint>(doubleClickTime))

   644             && (event->button == priv->previousClickButton)))

   645         priv->currentClickCount++;

   646     else

   647         priv->currentClickCount = 1;

   648 

   649     PlatformMouseEvent platformEvent(event);

   650     platformEvent.setClickCount(priv->currentClickCount);

   651     *priv->previousClickPoint = platformEvent.pos();

   652     priv->previousClickButton = event->button;

   653     priv->previousClickTime = eventTime;

   654 

   655     if (event->button == 3)

   656         return webkit_web_view_forward_context_menu_event(webView, PlatformMouseEvent(event));

   657 

   658     Frame* frame = core(webView)->mainFrame();

   659     if (!frame->view())

   660         return FALSE;

   661 

   662 

   663     gboolean result = frame->eventHandler()->handleMousePressEvent(platformEvent);

   664 

   665 #if PLATFORM(X11)

   666     /* Copy selection to the X11 selection clipboard */

   667     if (event->button == 2) {

   668         bool primary = webView->priv->usePrimaryForPaste;

   669         webView->priv->usePrimaryForPaste = true;

   670 

   671         Editor* editor = webView->priv->corePage->focusController()->focusedOrMainFrame()->editor();

   672         result = result || editor->canPaste() || editor->canDHTMLPaste();

   673         editor->paste();

   674 

   675         webView->priv->usePrimaryForPaste = primary;

   676     }

   677 #endif

   678 

   679     return result;

   680 }

   681 

   682 static gboolean webkit_web_view_button_release_event(GtkWidget* widget, GdkEventButton* event)

   683 {

   684     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   685 

   686     Frame* focusedFrame = core(webView)->focusController()->focusedFrame();

   687 

   688     if (focusedFrame && focusedFrame->editor()->canEdit()) {

   689 #ifdef MAEMO_CHANGES

   690         WebKitWebViewPrivate* priv = webView->priv;

   691         hildon_gtk_im_context_filter_event(priv->imContext, (GdkEvent*)event);

   692 #endif

   693     }

   694 

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

   696     if (mainFrame->view())

   697         mainFrame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));

   698 

   699     /* We always return FALSE here because WebKit can, for the same click, decide

   700      * to not handle press-event but handle release-event, which can totally confuse

   701      * some GTK+ containers when there are no other events in between. This way we

   702      * guarantee that this case never happens, and that if press-event goes through

   703      * release-event also goes through.

   704      */

   705 

   706     return FALSE;

   707 }

   708 

   709 static gboolean webkit_web_view_motion_event(GtkWidget* widget, GdkEventMotion* event)

   710 {

   711     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   712 

   713     Frame* frame = core(webView)->mainFrame();

   714     if (!frame->view())

   715         return FALSE;

   716 

   717     return frame->eventHandler()->mouseMoved(PlatformMouseEvent(event));

   718 }

   719 

   720 static gboolean webkit_web_view_scroll_event(GtkWidget* widget, GdkEventScroll* event)

   721 {

   722     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   723 

   724     Frame* frame = core(webView)->mainFrame();

   725     if (!frame->view())

   726         return FALSE;

   727 

   728     PlatformWheelEvent wheelEvent(event);

   729     return frame->eventHandler()->handleWheelEvent(wheelEvent);

   730 }

   731 

   732 static void webkit_web_view_size_request(GtkWidget* widget, GtkRequisition* requisition)

   733 {

   734     WebKitWebView* web_view = WEBKIT_WEB_VIEW(widget);

   735     Frame* coreFrame = core(webkit_web_view_get_main_frame(web_view));

   736     if (!coreFrame)

   737         return;

   738 

   739     FrameView* view = coreFrame->view();

   740     if (!view)

   741         return;

   742 

   743     requisition->width = view->contentsWidth();

   744     requisition->height = view->contentsHeight();

   745 }

   746 

   747 static void webkit_web_view_size_allocate(GtkWidget* widget, GtkAllocation* allocation)

   748 {

   749     GTK_WIDGET_CLASS(webkit_web_view_parent_class)->size_allocate(widget,allocation);

   750 

   751     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   752 

   753     Frame* frame = core(webView)->mainFrame();

   754     if (!frame->view())

   755         return;

   756 

   757     frame->view()->resize(allocation->width, allocation->height);

   758 }

   759 

   760 static void webkit_web_view_grab_focus(GtkWidget* widget)

   761 {

   762 

   763     if (gtk_widget_is_sensitive(widget)) {

   764         WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   765         FocusController* focusController = core(webView)->focusController();

   766 

   767         focusController->setActive(true);

   768 

   769         if (focusController->focusedFrame())

   770             focusController->setFocused(true);

   771         else

   772             focusController->setFocusedFrame(core(webView)->mainFrame());

   773     }

   774 

   775     return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->grab_focus(widget);

   776 }

   777 

   778 static gboolean webkit_web_view_focus_in_event(GtkWidget* widget, GdkEventFocus* event)

   779 {

   780     // TODO: Improve focus handling as suggested in

   781     // http://bugs.webkit.org/show_bug.cgi?id=16910

   782     GtkWidget* toplevel = gtk_widget_get_toplevel(widget);

   783     if (gtk_widget_is_toplevel(toplevel) && gtk_window_has_toplevel_focus(GTK_WINDOW(toplevel))) {

   784         WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   785         FocusController* focusController = core(webView)->focusController();

   786 

   787         focusController->setActive(true);

   788 

   789         if (focusController->focusedFrame())

   790             focusController->setFocused(true);

   791         else

   792             focusController->setFocusedFrame(core(webView)->mainFrame());

   793 

   794         gtk_im_context_focus_in(webView->priv->imContext);

   795     }

   796     return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->focus_in_event(widget, event);

   797 }

   798 

   799 static gboolean webkit_web_view_focus_out_event(GtkWidget* widget, GdkEventFocus* event)

   800 {

   801     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   802 

   803     // We may hit this code while destroying the widget, and we might

   804     // no longer have a page, then.

   805     Page* page = core(webView);

   806     if (page) {

   807         page->focusController()->setActive(false);

   808         page->focusController()->setFocused(false);

   809     }

   810 

   811     if (webView->priv->imContext)

   812         gtk_im_context_focus_out(webView->priv->imContext);

   813 

   814     return GTK_WIDGET_CLASS(webkit_web_view_parent_class)->focus_out_event(widget, event);

   815 }

   816 

   817 static void webkit_web_view_realize(GtkWidget* widget)

   818 {

   819     gtk_widget_set_realized(widget, TRUE);

   820 

   821     GtkAllocation allocation;

   822 #if GTK_CHECK_VERSION(2, 18, 0)

   823     gtk_widget_get_allocation(widget, &allocation);

   824 #else

   825     allocation = widget->allocation;

   826 #endif

   827 

   828     GdkWindowAttr attributes;

   829     attributes.window_type = GDK_WINDOW_CHILD;

   830     attributes.x = allocation.x;

   831     attributes.y = allocation.y;

   832     attributes.width = allocation.width;

   833     attributes.height = allocation.height;

   834     attributes.wclass = GDK_INPUT_OUTPUT;

   835     attributes.visual = gtk_widget_get_visual(widget);

   836     attributes.colormap = gtk_widget_get_colormap(widget);

   837     attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK

   838                             | GDK_EXPOSURE_MASK

   839                             | GDK_BUTTON_PRESS_MASK

   840                             | GDK_BUTTON_RELEASE_MASK

   841                             | GDK_POINTER_MOTION_MASK

   842                             | GDK_KEY_PRESS_MASK

   843                             | GDK_KEY_RELEASE_MASK

   844                             | GDK_BUTTON_MOTION_MASK

   845                             | GDK_BUTTON1_MOTION_MASK

   846                             | GDK_BUTTON2_MOTION_MASK

   847                             | GDK_BUTTON3_MOTION_MASK;

   848 

   849     gint attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

   850     GdkWindow* window = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributes_mask);

   851     gtk_widget_set_window(widget, window);

   852     gdk_window_set_user_data(window, widget);

   853 

   854 #if GTK_CHECK_VERSION(2, 20, 0)

   855     gtk_widget_style_attach(widget);

   856 #else

   857     widget->style = gtk_style_attach(gtk_widget_get_style(widget), window);

   858 #endif

   859     gtk_style_set_background(gtk_widget_get_style(widget), window, GTK_STATE_NORMAL);

   860 

   861     WebKitWebView* webView = WEBKIT_WEB_VIEW(widget);

   862     WebKitWebViewPrivate* priv = webView->priv;

   863     gtk_im_context_set_client_window(priv->imContext, window);

   864 }

   865 

   866 static void webkit_web_view_set_scroll_adjustments(WebKitWebView* webView, GtkAdjustment* hadj, GtkAdjustment* vadj)

   867 {

   868     if (!core(webView))

   869         return;

   870 

   871     FrameView* view = core(webkit_web_view_get_main_frame(webView))->view();

   872 

   873     if (hadj)

   874         g_object_ref(hadj);

   875     if (vadj)

   876         g_object_ref(vadj);

   877 

   878     WebKitWebViewPrivate* priv = webView->priv;

   879 

   880     if (priv->horizontalAdjustment)

   881         g_object_unref(priv->horizontalAdjustment);

   882     if (priv->verticalAdjustment)

   883         g_object_unref(priv->verticalAdjustment);

   884 

   885     priv->horizontalAdjustment = hadj;

   886     priv->verticalAdjustment = vadj;

   887 

   888     if (!view)

   889         return;

   890 

   891     view->setGtkAdjustments(hadj, vadj);

   892 }

   893 

   894 static void webkit_web_view_container_add(GtkContainer* container, GtkWidget* widget)

   895 {

   896     WebKitWebView* webView = WEBKIT_WEB_VIEW(container);

   897     WebKitWebViewPrivate* priv = webView->priv;

   898 

   899     priv->children.add(widget);

   900     gtk_widget_set_parent(widget, GTK_WIDGET(container));

   901 }

   902 

   903 static void webkit_web_view_container_remove(GtkContainer* container, GtkWidget* widget)

   904 {

   905     WebKitWebView* webView = WEBKIT_WEB_VIEW(container);

   906     WebKitWebViewPrivate* priv = webView->priv;

   907 

   908     if (priv->children.contains(widget)) {

   909         gtk_widget_unparent(widget);

   910         priv->children.remove(widget);

   911     }

   912 }

   913 

   914 static void webkit_web_view_container_forall(GtkContainer* container, gboolean, GtkCallback callback, gpointer callbackData)

   915 {

   916     WebKitWebView* webView = WEBKIT_WEB_VIEW(container);

   917     WebKitWebViewPrivate* priv = webView->priv;

   918 

   919     HashSet<GtkWidget*> children = priv->children;

   920     HashSet<GtkWidget*>::const_iterator end = children.end();

   921     for (HashSet<GtkWidget*>::const_iterator current = children.begin(); current != end; ++current)

   922         (*callback)(*current, callbackData);

   923 }

   924 

   925 static WebKitWebView* webkit_web_view_real_create_web_view(WebKitWebView*, WebKitWebFrame*)

   926 {

   927     return 0;

   928 }

   929 

   930 static gboolean webkit_web_view_real_web_view_ready(WebKitWebView*)

   931 {

   932     return FALSE;

   933 }

   934 

   935 static gboolean webkit_web_view_real_close_web_view(WebKitWebView*)

   936 {

   937     return FALSE;

   938 }

   939 

   940 static WebKitNavigationResponse webkit_web_view_real_navigation_requested(WebKitWebView*, WebKitWebFrame*, WebKitNetworkRequest*)

   941 {

   942     return WEBKIT_NAVIGATION_RESPONSE_ACCEPT;

   943 }

   944 

   945 static void webkit_web_view_real_window_object_cleared(WebKitWebView*, WebKitWebFrame*, JSGlobalContextRef context, JSObjectRef window_object)

   946 {

   947     notImplemented();

   948 }

   949 

   950 static gchar* webkit_web_view_real_choose_file(WebKitWebView*, WebKitWebFrame*, const gchar* old_name)

   951 {

   952     notImplemented();

   953     return g_strdup(old_name);

   954 }

   955 

   956 typedef enum {

   957     WEBKIT_SCRIPT_DIALOG_ALERT,

   958     WEBKIT_SCRIPT_DIALOG_CONFIRM,

   959     WEBKIT_SCRIPT_DIALOG_PROMPT

   960  } WebKitScriptDialogType;

   961 

   962 static gboolean webkit_web_view_script_dialog(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, WebKitScriptDialogType type, const gchar* defaultValue, gchar** value)

   963 {

   964     GtkMessageType messageType;

   965     GtkButtonsType buttons;

   966     gint defaultResponse;

   967     GtkWidget* window;

   968     GtkWidget* dialog;

   969     GtkWidget* entry = 0;

   970     gboolean didConfirm = FALSE;

   971 

   972     switch (type) {

   973     case WEBKIT_SCRIPT_DIALOG_ALERT:

   974         messageType = GTK_MESSAGE_WARNING;

   975         buttons = GTK_BUTTONS_CLOSE;

   976         defaultResponse = GTK_RESPONSE_CLOSE;

   977         break;

   978     case WEBKIT_SCRIPT_DIALOG_CONFIRM:

   979         messageType = GTK_MESSAGE_QUESTION;

   980         buttons = GTK_BUTTONS_YES_NO;

   981         defaultResponse = GTK_RESPONSE_YES;

   982         break;

   983     case WEBKIT_SCRIPT_DIALOG_PROMPT:

   984         messageType = GTK_MESSAGE_QUESTION;

   985         buttons = GTK_BUTTONS_OK_CANCEL;

   986         defaultResponse = GTK_RESPONSE_OK;

   987         break;

   988     default:

   989         g_warning("Unknown value for WebKitScriptDialogType.");

   990         return FALSE;

   991     }

   992 

   993     window = gtk_widget_get_toplevel(GTK_WIDGET(webView));

   994     dialog = gtk_message_dialog_new(gtk_widget_is_toplevel(window) ? GTK_WINDOW(window) : 0, GTK_DIALOG_DESTROY_WITH_PARENT, messageType, buttons, "%s", message);

   995     gchar* title = g_strconcat("JavaScript - ", webkit_web_frame_get_uri(frame), NULL);

   996     gtk_window_set_title(GTK_WINDOW(dialog), title);

   997     g_free(title);

   998 

   999     if (type == WEBKIT_SCRIPT_DIALOG_PROMPT) {

  1000         entry = gtk_entry_new();

  1001         gtk_entry_set_text(GTK_ENTRY(entry), defaultValue);

  1002         gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), entry);

  1003         gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);

  1004         gtk_widget_show(entry);

  1005     }

  1006 

  1007     gtk_dialog_set_default_response(GTK_DIALOG(dialog), defaultResponse);

  1008     gint response = gtk_dialog_run(GTK_DIALOG(dialog));

  1009 

  1010     switch (response) {

  1011     case GTK_RESPONSE_YES:

  1012         didConfirm = TRUE;

  1013         break;

  1014     case GTK_RESPONSE_OK:

  1015         didConfirm = TRUE;

  1016         if (entry)

  1017             *value = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));

  1018         else

  1019             *value = 0;

  1020         break;

  1021     case GTK_RESPONSE_NO:

  1022     case GTK_RESPONSE_CANCEL:

  1023         didConfirm = FALSE;

  1024         break;

  1025 

  1026     }

  1027     gtk_widget_destroy(GTK_WIDGET(dialog));

  1028     return didConfirm;

  1029 }

  1030 

  1031 static gboolean webkit_web_view_real_script_alert(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message)

  1032 {

  1033     webkit_web_view_script_dialog(webView, frame, message, WEBKIT_SCRIPT_DIALOG_ALERT, 0, 0);

  1034     return TRUE;

  1035 }

  1036 

  1037 static gboolean webkit_web_view_real_script_confirm(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, gboolean* didConfirm)

  1038 {

  1039     *didConfirm = webkit_web_view_script_dialog(webView, frame, message, WEBKIT_SCRIPT_DIALOG_CONFIRM, 0, 0);

  1040     return TRUE;

  1041 }

  1042 

  1043 static gboolean webkit_web_view_real_script_prompt(WebKitWebView* webView, WebKitWebFrame* frame, const gchar* message, const gchar* defaultValue, gchar** value)

  1044 {

  1045     if (!webkit_web_view_script_dialog(webView, frame, message, WEBKIT_SCRIPT_DIALOG_PROMPT, defaultValue, value))

  1046         *value = NULL;

  1047     return TRUE;

  1048 }

  1049 

  1050 static gboolean webkit_web_view_real_console_message(WebKitWebView* webView, const gchar* message, unsigned int line, const gchar* sourceId)

  1051 {

  1052     g_message("console message: %s @%d: %s\n", sourceId, line, message);

  1053     return TRUE;

  1054 }

  1055 

  1056 static void webkit_web_view_real_select_all(WebKitWebView* webView)

  1057 {

  1058     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

  1059     frame->editor()->command("SelectAll").execute();

  1060 }

  1061 

  1062 static void webkit_web_view_real_cut_clipboard(WebKitWebView* webView)

  1063 {

  1064     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

  1065     frame->editor()->command("Cut").execute();

  1066 }

  1067 

  1068 static void webkit_web_view_real_copy_clipboard(WebKitWebView* webView)

  1069 {

  1070     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

  1071     frame->editor()->command("Copy").execute();

  1072 }

  1073 

  1074 static void webkit_web_view_real_undo(WebKitWebView* webView)

  1075 {

  1076     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

  1077     frame->editor()->command("Undo").execute();

  1078 }

  1079 

  1080 static void webkit_web_view_real_redo(WebKitWebView* webView)

  1081 {

  1082     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

  1083     frame->editor()->command("Redo").execute();

  1084 }

  1085 

  1086 static gboolean webkit_web_view_real_move_cursor (WebKitWebView* webView, GtkMovementStep step, gint count)

  1087 {

  1088     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW (webView), FALSE);

  1089     g_return_val_if_fail(step == GTK_MOVEMENT_VISUAL_POSITIONS ||

  1090                          step == GTK_MOVEMENT_DISPLAY_LINES ||

  1091                          step == GTK_MOVEMENT_PAGES ||

  1092                          step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);

  1093     g_return_val_if_fail(count == 1 || count == -1, FALSE);

  1094 

  1095     ScrollDirection direction;

  1096     ScrollGranularity granularity;

  1097 

  1098     switch (step) {

  1099     case GTK_MOVEMENT_DISPLAY_LINES:

  1100         granularity = ScrollByLine;

  1101         if (count == 1)

  1102             direction = ScrollDown;

  1103         else

  1104             direction = ScrollUp;

  1105         break;

  1106     case GTK_MOVEMENT_VISUAL_POSITIONS:

  1107         granularity = ScrollByLine;

  1108         if (count == 1)

  1109             direction = ScrollRight;

  1110         else

  1111             direction = ScrollLeft;

  1112         break;

  1113     case GTK_MOVEMENT_PAGES:

  1114         granularity = ScrollByPage;

  1115         if (count == 1)

  1116             direction = ScrollDown;

  1117         else

  1118             direction = ScrollUp;

  1119         break;

  1120     case GTK_MOVEMENT_BUFFER_ENDS:

  1121         granularity = ScrollByDocument;

  1122         if (count == 1)

  1123             direction = ScrollDown;

  1124         else

  1125             direction = ScrollUp;

  1126         break;

  1127     default:

  1128         g_assert_not_reached();

  1129         return false;

  1130     }

  1131 

  1132     Frame* frame = core(webView)->focusController()->focusedOrMainFrame();

  1133     if (!frame->eventHandler()->scrollOverflow(direction, granularity))

  1134         frame->view()->scroll(direction, granularity);

  1135