1 /*

     2  * Copyright (C) 2007 Holger Hans Peter Freyther

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  *

     8  * 1.  Redistributions of source code must retain the above copyright

     9  *     notice, this list of conditions and the following disclaimer. 

    10  * 2.  Redistributions in binary form must reproduce the above copyright

    11  *     notice, this list of conditions and the following disclaimer in the

    12  *     documentation and/or other materials provided with the distribution. 

    13  * 3.  Neither the name of Apple, Inc. ("Apple") nor the names of

    14  *     its contributors may be used to endorse or promote products derived

    15  *     from this software without specific prior written permission. 

    16  *

    17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    27  */

    28 

    29 #include "config.h"

    30 

    31 #include "webkitgtkpage.h"

    32 #include "webkitgtk-marshal.h"

    33 #include "webkitgtkprivate.h"

    34 

    35 #include "NotImplemented.h"

    36 #include "ChromeClientGtk.h"

    37 #include "ContextMenuClientGtk.h"

    38 #include "DragClientGtk.h"

    39 #include "EditorClientGtk.h"

    40 #include "EventHandler.h"

    41 #include "HitTestRequest.h"

    42 #include "HitTestResult.h"

    43 #include "GraphicsContext.h"

    44 #include "InspectorClientGtk.h"

    45 #include "FrameLoader.h"

    46 #include "FrameView.h"

    47 #include "PlatformKeyboardEvent.h"

    48 #include "PlatformWheelEvent.h"

    49 #include "SubstituteData.h"

    50 

    51 

    52 using namespace WebKit;

    53 using namespace WebCore;

    54 

    55 extern "C" {

    56 

    57 enum {

    58     /* normal signals */

    59     LOAD_STARTED,

    60     LOAD_PROGRESS_CHANGED,

    61     LOAD_FINISHED,

    62     TITLE_CHANGED,

    63     HOVERING_OVER_LINK,

    64     STATUS_BAR_TEXT_CHANGED,

    65     ICOND_LOADED,

    66     SELECTION_CHANGED,

    67     LAST_SIGNAL

    68 };

    69 

    70 static guint webkit_page_signals[LAST_SIGNAL] = { 0, };

    71 

    72 G_DEFINE_TYPE(WebKitPage, webkit_page, GTK_TYPE_CONTAINER)

    73 

    74 static gboolean webkit_page_expose_event(GtkWidget* widget, GdkEventExpose* event)

    75 {

    76     Frame* frame = core(getFrameFromPage(WEBKIT_PAGE(widget)));

    77     GdkRectangle clip;

    78     gdk_region_get_clipbox(event->region, &clip);

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

    80     GraphicsContext ctx(cr);

    81     ctx.setGdkExposeEvent(event);

    82     if (frame->renderer()) {

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

    84         IntRect rect(clip.x, clip.y, clip.width, clip.height);

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

    86     }

    87     cairo_destroy(cr);

    88 

    89     return FALSE;

    90 }

    91 

    92 static gboolean webkit_page_key_event(GtkWidget* widget, GdkEventKey* event)

    93 {

    94     Frame* frame = core(getFrameFromPage(WEBKIT_PAGE(widget)));

    95     frame->eventHandler()->keyEvent(PlatformKeyboardEvent(event));

    96     return FALSE;

    97 }

    98 

    99 static gboolean webkit_page_button_event(GtkWidget* widget, GdkEventButton* event)

   100 {

   101     Frame* frame = core(getFrameFromPage(WEBKIT_PAGE(widget)));

   102 

   103     if (event->type == GDK_BUTTON_RELEASE)

   104         frame->eventHandler()->handleMouseReleaseEvent(PlatformMouseEvent(event));

   105     else

   106         frame->eventHandler()->handleMousePressEvent(PlatformMouseEvent(event));

   107 

   108     return FALSE;

   109 }

   110 

   111 static gboolean webkit_page_motion_event(GtkWidget* widget, GdkEventMotion* event)

   112 {

   113     Frame* frame = core(getFrameFromPage(WEBKIT_PAGE(widget)));

   114     frame->eventHandler()->mouseMoved(PlatformMouseEvent(event));

   115     return FALSE;

   116 }

   117 

   118 static gboolean webkit_page_scroll_event(GtkWidget* widget, GdkEventScroll* event)

   119 {

   120     Frame* frame = core(getFrameFromPage(WEBKIT_PAGE(widget)));

   121 

   122     PlatformWheelEvent wheelEvent(event);

   123     frame->eventHandler()->handleWheelEvent(wheelEvent);

   124     return FALSE;

   125 }

   126 

   127 static void webkit_page_size_allocate(GtkWidget* widget, GtkAllocation* allocation)

   128 {

   129     GTK_WIDGET_CLASS(webkit_page_parent_class)->size_allocate(widget,allocation);

   130 

   131     Frame* frame = core(getFrameFromPage(WEBKIT_PAGE(widget)));

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

   133     frame->forceLayout();

   134     frame->view()->adjustViewSize();

   135     frame->sendResizeEvent();

   136 }

   137 

   138 static void webkit_page_realize(GtkWidget* widget)

   139 {

   140     GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);

   141 

   142     GdkWindowAttr attributes;

   143     attributes.window_type = GDK_WINDOW_CHILD;

   144     attributes.x = widget->allocation.x;

   145     attributes.y = widget->allocation.y;

   146     attributes.width = widget->allocation.width;

   147     attributes.height = widget->allocation.height;

   148     attributes.wclass = GDK_INPUT_OUTPUT;

   149     attributes.visual = gtk_widget_get_visual (widget);

   150     attributes.colormap = gtk_widget_get_colormap (widget);

   151     attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK

   152                             | GDK_EXPOSURE_MASK

   153                             | GDK_BUTTON_PRESS_MASK

   154                             | GDK_BUTTON_RELEASE_MASK

   155                             | GDK_POINTER_MOTION_MASK

   156                             | GDK_KEY_PRESS_MASK

   157                             | GDK_KEY_RELEASE_MASK

   158                             | GDK_BUTTON_MOTION_MASK

   159                             | GDK_BUTTON1_MOTION_MASK

   160                             | GDK_BUTTON2_MOTION_MASK

   161                             | GDK_BUTTON3_MOTION_MASK;

   162 

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

   164     widget->window = gdk_window_new(gtk_widget_get_parent_window (widget), &attributes, attributes_mask);

   165     gdk_window_set_user_data(widget->window, widget);

   166 }

   167 

   168 static void webkit_page_map(GtkWidget* widget)

   169 {

   170     GTK_WIDGET_SET_FLAGS(widget, GTK_MAPPED);

   171     WebKitPagePrivate* private_data = WEBKIT_PAGE_GET_PRIVATE(WEBKIT_PAGE(widget));

   172 

   173     HashSet<GtkWidget*>::const_iterator end = private_data->children.end();

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

   175         if (GTK_WIDGET_VISIBLE(*current) && !GTK_WIDGET_MAPPED(*current))

   176             gtk_widget_map((*current));

   177 

   178     gdk_window_show(widget->window);

   179 }

   180 

   181 static void webkit_page_set_scroll_adjustments(WebKitPage* page, GtkAdjustment* hadj, GtkAdjustment* vadj)

   182 {

   183     FrameView* view = core(getFrameFromPage(page))->view();

   184     view->setGtkAdjustments(hadj, vadj);

   185 }

   186 

   187 static void webkit_page_container_add(GtkContainer* container, GtkWidget* widget)

   188 {

   189     WebKitPage* page = WEBKIT_PAGE(container);

   190     WebKitPagePrivate* private_data = WEBKIT_PAGE_GET_PRIVATE(page);

   191 

   192     private_data->children.add(widget);

   193     if (GTK_WIDGET_REALIZED(container))

   194         gtk_widget_set_parent_window(widget, GTK_WIDGET(page)->window);

   195     gtk_widget_set_parent(widget, GTK_WIDGET(container));

   196 }

   197 

   198 static void webkit_page_container_remove(GtkContainer* container, GtkWidget* widget)

   199 {

   200     WebKitPagePrivate* private_data = WEBKIT_PAGE_GET_PRIVATE(WEBKIT_PAGE(container));

   201 

   202     if (private_data->children.contains(widget)) {

   203         gtk_widget_unparent(widget);

   204         private_data->children.remove(widget);

   205     }

   206 }

   207 

   208 static void webkit_page_container_forall(GtkContainer* container, gboolean, GtkCallback callback, gpointer callbackData)

   209 {

   210     WebKitPagePrivate* privateData = WEBKIT_PAGE_GET_PRIVATE(WEBKIT_PAGE(container));

   211 

   212     HashSet<GtkWidget*> children = privateData->children;

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

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

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

   216 }

   217 

   218 static WebKitPage* webkit_page_real_create_page(WebKitPage*)

   219 {

   220     notImplemented();

   221     return 0;

   222 }

   223 

   224 static WEBKIT_NAVIGATION_REQUEST_RESPONSE webkit_page_real_navigation_requested(WebKitPage*, WebKitFrame* frame, WebKitNetworkRequest*)

   225 {

   226     notImplemented();

   227     return WEBKIT_ACCEPT_NAVIGATION_REQUEST;

   228 }

   229 

   230 static gchar* webkit_page_real_choose_file(WebKitPage*, WebKitFrame*, const gchar* old_name)

   231 {

   232     notImplemented();

   233     return g_strdup(old_name);

   234 }

   235 

   236 static void webkit_page_real_java_script_alert(WebKitPage*, WebKitFrame*, const gchar*)

   237 {

   238     notImplemented();

   239 }

   240 

   241 static gboolean webkit_page_real_java_script_confirm(WebKitPage*, WebKitFrame*, const gchar*)

   242 {

   243     notImplemented();

   244     return FALSE;

   245 }

   246 

   247 /**

   248  * WebKitPage::java_script_prompt

   249  *

   250  * @return: NULL to cancel the prompt

   251  */

   252 static gchar* webkit_page_real_java_script_prompt(WebKitPage*, WebKitFrame*, const gchar*, const gchar* defaultValue)

   253 {

   254     notImplemented();

   255     return g_strdup(defaultValue);

   256 }

   257 

   258 static void webkit_page_real_java_script_console_message(WebKitPage*, const gchar*, unsigned int, const gchar*)

   259 {

   260     notImplemented();

   261 }

   262 

   263 static void webkit_page_finalize(GObject* object)

   264 {

   265     webkit_page_stop_loading(WEBKIT_PAGE(object));

   266 

   267     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(WEBKIT_PAGE(object));

   268     delete pageData->page;

   269     delete pageData->settings;

   270     g_object_unref(pageData->mainFrame);

   271     delete pageData->userAgent;

   272 

   273     G_OBJECT_CLASS(webkit_page_parent_class)->finalize(object);

   274 }

   275 

   276 static void webkit_page_class_init(WebKitPageClass* pageClass)

   277 {

   278     g_type_class_add_private(pageClass, sizeof(WebKitPagePrivate));

   279 

   280 

   281     /*

   282      * signals

   283      */

   284     /**

   285      * WebKitPage::load-started

   286      * @page: the object on which the signal is emitted

   287      * @frame: the frame going to do the load

   288      *

   289      * When a WebKitFrame begins to load this signal is emitted.

   290      */

   291     webkit_page_signals[LOAD_STARTED] = g_signal_new("load_started",

   292             G_TYPE_FROM_CLASS(pageClass),

   293             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   294             0,

   295             NULL,

   296             NULL,

   297             g_cclosure_marshal_VOID__OBJECT,

   298             G_TYPE_NONE, 1,

   299             WEBKIT_TYPE_FRAME);

   300 

   301     /**

   302      * WebKitPage::load-progress-changed

   303      * @page: The WebKitPage

   304      * @progress: Global progress

   305      */

   306     webkit_page_signals[LOAD_PROGRESS_CHANGED] = g_signal_new("load_progress_changed",

   307             G_TYPE_FROM_CLASS(pageClass),

   308             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   309             0,

   310             NULL,

   311             NULL,

   312             g_cclosure_marshal_VOID__INT,

   313             G_TYPE_NONE, 1,

   314             G_TYPE_INT);

   315     

   316     webkit_page_signals[LOAD_FINISHED] = g_signal_new("load_finished",

   317             G_TYPE_FROM_CLASS(pageClass),

   318             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   319             0,

   320             NULL,

   321             NULL,

   322             g_cclosure_marshal_VOID__OBJECT,

   323             G_TYPE_NONE, 1,

   324             WEBKIT_TYPE_FRAME);

   325 

   326     webkit_page_signals[TITLE_CHANGED] = g_signal_new("title_changed",

   327             G_TYPE_FROM_CLASS(pageClass),

   328             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   329             0,

   330             NULL,

   331             NULL,

   332             webkit_marshal_VOID__STRING_STRING,

   333             G_TYPE_NONE, 2,

   334             G_TYPE_STRING, G_TYPE_STRING);

   335 

   336     webkit_page_signals[HOVERING_OVER_LINK] = g_signal_new("hovering_over_link",

   337             G_TYPE_FROM_CLASS(pageClass),

   338             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   339             0,

   340             NULL,

   341             NULL,

   342             webkit_marshal_VOID__STRING_STRING,

   343             G_TYPE_NONE, 2,

   344             G_TYPE_STRING,

   345             G_TYPE_STRING);

   346 

   347     webkit_page_signals[STATUS_BAR_TEXT_CHANGED] = g_signal_new("status_bar_text_changed",

   348             G_TYPE_FROM_CLASS(pageClass),

   349             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   350             0,

   351             NULL,

   352             NULL,

   353             g_cclosure_marshal_VOID__STRING,

   354             G_TYPE_NONE, 1,

   355             G_TYPE_STRING);

   356 

   357     webkit_page_signals[ICOND_LOADED] = g_signal_new("icon_loaded",

   358             G_TYPE_FROM_CLASS(pageClass),

   359             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   360             0,

   361             NULL,

   362             NULL,

   363             g_cclosure_marshal_VOID__VOID,

   364             G_TYPE_NONE, 0);

   365 

   366     webkit_page_signals[SELECTION_CHANGED] = g_signal_new("selection_changed",

   367             G_TYPE_FROM_CLASS(pageClass),

   368             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   369             0,

   370             NULL,

   371             NULL,

   372             g_cclosure_marshal_VOID__VOID,

   373             G_TYPE_NONE, 0);

   374 

   375 

   376     /*

   377      * implementations of virtual methods

   378      */

   379     pageClass->create_page = webkit_page_real_create_page;

   380     pageClass->navigation_requested = webkit_page_real_navigation_requested;

   381     pageClass->choose_file = webkit_page_real_choose_file;

   382     pageClass->java_script_alert = webkit_page_real_java_script_alert;

   383     pageClass->java_script_confirm = webkit_page_real_java_script_confirm;

   384     pageClass->java_script_prompt = webkit_page_real_java_script_prompt;

   385     pageClass->java_script_console_message = webkit_page_real_java_script_console_message;

   386 

   387     G_OBJECT_CLASS(pageClass)->finalize = webkit_page_finalize;

   388 

   389     GtkWidgetClass* widgetClass = GTK_WIDGET_CLASS(pageClass);

   390     widgetClass->realize = webkit_page_realize;

   391     widgetClass->map = webkit_page_map;

   392     widgetClass->expose_event = webkit_page_expose_event;

   393     widgetClass->key_press_event = webkit_page_key_event;

   394     widgetClass->key_release_event = webkit_page_key_event;

   395     widgetClass->button_press_event = webkit_page_button_event;

   396     widgetClass->button_release_event = webkit_page_button_event;

   397     widgetClass->motion_notify_event = webkit_page_motion_event;

   398     widgetClass->scroll_event = webkit_page_scroll_event;

   399     widgetClass->size_allocate = webkit_page_size_allocate;

   400 

   401     GtkContainerClass* containerClass = GTK_CONTAINER_CLASS(pageClass);

   402     containerClass->add = webkit_page_container_add;

   403     containerClass->remove = webkit_page_container_remove;

   404     containerClass->forall = webkit_page_container_forall;

   405 

   406     /*

   407      * make us scrollable (e.g. addable to a GtkScrolledWindow)

   408      */

   409     pageClass->set_scroll_adjustments = webkit_page_set_scroll_adjustments;

   410     GTK_WIDGET_CLASS(pageClass)->set_scroll_adjustments_signal = g_signal_new("set_scroll_adjustments",

   411             G_TYPE_FROM_CLASS(pageClass),

   412             (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),

   413             G_STRUCT_OFFSET(WebKitPageClass, set_scroll_adjustments),

   414             NULL, NULL,

   415             webkit_marshal_VOID__OBJECT_OBJECT,

   416             G_TYPE_NONE, 2,

   417             GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);

   418 }

   419 

   420 static void webkit_page_init(WebKitPage* page)

   421 {

   422     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(WEBKIT_PAGE(page));

   423     pageData->page = new Page(new WebKit::ChromeClient(page), new WebKit::ContextMenuClient, new WebKit::EditorClient(page), new WebKit::DragClient, new WebKit::InspectorClient);

   424 

   425     Settings* settings = pageData->page->settings();

   426     settings->setLoadsImagesAutomatically(true);

   427     settings->setMinimumFontSize(5);

   428     settings->setMinimumLogicalFontSize(5);

   429     settings->setShouldPrintBackgrounds(true);

   430     settings->setJavaScriptEnabled(true);

   431     settings->setDefaultFixedFontSize(14);

   432     settings->setDefaultFontSize(14);

   433     settings->setSerifFontFamily("Times New Roman");

   434     settings->setSansSerifFontFamily("Arial");

   435     settings->setFixedFontFamily("Courier");

   436     settings->setStandardFontFamily("Arial");

   437 

   438     GTK_WIDGET_SET_FLAGS(page, GTK_CAN_FOCUS);

   439     pageData->mainFrame = WEBKIT_FRAME(webkit_frame_new(page));

   440 }

   441 

   442 GtkWidget* webkit_page_new(void)

   443 {

   444     WebKitPage* page = WEBKIT_PAGE(g_object_new(WEBKIT_TYPE_PAGE, NULL));

   445 

   446     return GTK_WIDGET(page);

   447 }

   448 

   449 void webkit_page_set_settings(WebKitPage* page, WebKitSettings* settings)

   450 {

   451     notImplemented();

   452 }

   453 

   454 WebKitSettings* webkit_page_get_settings(WebKitPage* page)

   455 {

   456     notImplemented();

   457     return 0;

   458 }

   459 

   460 void webkit_page_go_backward(WebKitPage* page)

   461 {

   462     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   463     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   464     frameData->frame->loader()->goBackOrForward(-1);

   465 }

   466 

   467 void webkit_page_go_forward(WebKitPage* page)

   468 {

   469     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   470     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   471     frameData->frame->loader()->goBackOrForward(1);

   472 }

   473 

   474 gboolean webkit_page_can_go_backward(WebKitPage* page)

   475 {

   476     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   477     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   478     return frameData->frame->loader()->canGoBackOrForward(-1);

   479 }

   480 

   481 gboolean webkit_page_can_go_forward(WebKitPage* page)

   482 {

   483     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   484     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   485     return frameData->frame->loader()->canGoBackOrForward(1);

   486 }

   487 

   488 void webkit_page_open(WebKitPage* page, const gchar* url)

   489 {

   490     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   491     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   492 

   493     DeprecatedString string = DeprecatedString::fromUtf8(url);

   494     frameData->frame->loader()->load(ResourceRequest(KURL(string)));

   495 }

   496 

   497 void webkit_page_reload(WebKitPage* page)

   498 {

   499     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   500     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   501     frameData->frame->loader()->reload();

   502 }

   503 

   504 void webkit_page_load_string(WebKitPage* page, const gchar* content, const gchar* contentMimeType, const gchar* contentEncoding, const gchar* baseUrl)

   505 {

   506     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   507     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   508     

   509     KURL url(DeprecatedString::fromUtf8(baseUrl));

   510     RefPtr<SharedBuffer> sharedBuffer = new SharedBuffer(strdup(content), strlen(content));    

   511     SubstituteData substituteData(sharedBuffer.release(), String(contentMimeType), String(contentEncoding), KURL("about:blank"), url);

   512 

   513     frameData->frame->loader()->load(ResourceRequest(url), substituteData);

   514 }

   515 

   516 void webkit_page_load_html_string(WebKitPage* page, const gchar* content, const gchar* baseUrl)

   517 {

   518     webkit_page_load_string(page, content, "text/html", "UTF-8", baseUrl);

   519 }

   520 

   521 void webkit_page_stop_loading(WebKitPage* page)

   522 {

   523     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   524     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   525     

   526     if (FrameLoader* loader = frameData->frame->loader())

   527         loader->stopAllLoaders();

   528         

   529 }

   530 

   531 WebKitFrame* webkit_page_get_main_frame(WebKitPage* page)

   532 {

   533     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   534     return pageData->mainFrame;

   535 }

   536 

   537 void webkit_page_execute_script(WebKitPage* page, const gchar* script)

   538 {

   539     WebKitPagePrivate* pageData = WEBKIT_PAGE_GET_PRIVATE(page);

   540     WebKitFramePrivate* frameData = WEBKIT_FRAME_GET_PRIVATE(pageData->mainFrame);

   541 

   542     if (FrameLoader* loader = frameData->frame->loader())

   543         loader->executeScript(String::fromUTF8(script), true);

   544 }

   545 }