Tools/GtkLauncher/main.c

   1 /*
   2  * Copyright (C) 2006, 2007 Apple Inc.
   3  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
   4  * Copyright (C) 2011 Lukasz Slachciak
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <errno.h>
  29 #include <gtk/gtk.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <webkit/webkit.h>
  33
  34 static gint windowCount = 0;
  35
  36 static GtkWidget* createWindow(WebKitWebView** outWebView);
  37
  38 static void activateUriEntryCb(GtkWidget* entry, gpointer data)
  39 {
  40     WebKitWebView *webView = g_object_get_data(G_OBJECT(entry), "web-view");
  41     const gchar* uri = gtk_entry_get_text(GTK_ENTRY(entry));
  42     g_assert(uri);
  43     webkit_web_view_load_uri(webView, uri);
  44 }
  45
  46 static void updateTitle(GtkWindow* window, WebKitWebView* webView)
  47 {
  48     GString *string = g_string_new(webkit_web_view_get_title(webView));
  49     gdouble loadProgress = webkit_web_view_get_progress(webView) * 100;
  50     g_string_append(string, " - WebKit Launcher");
  51     if (loadProgress < 100)
  52         g_string_append_printf(string, " (%f%%)", loadProgress);
  53     gchar *title = g_string_free(string, FALSE);
  54     gtk_window_set_title(window, title);
  55     g_free(title);
  56 }
  57
  58 static void linkHoverCb(WebKitWebView* page, const gchar* title, const gchar* link, GtkStatusbar* statusbar)
  59 {
  60     guint statusContextId =
  61       GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(statusbar), "link-hover-context"));
  62     /* underflow is allowed */
  63     gtk_statusbar_pop(statusbar, statusContextId);
  64     if (link)
  65         gtk_statusbar_push(statusbar, statusContextId, link);
  66 }
  67
  68 static void notifyTitleCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* window)
  69 {
  70     updateTitle(GTK_WINDOW(window), webView);
  71 }
  72
  73 static void notifyLoadStatusCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* uriEntry)
  74 {
  75     if (webkit_web_view_get_load_status(webView) == WEBKIT_LOAD_COMMITTED) {
  76         WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
  77         const gchar *uri = webkit_web_frame_get_uri(frame);
  78         if (uri)
  79             gtk_entry_set_text(GTK_ENTRY(uriEntry), uri);
  80     }
  81 }
  82
  83 static void notifyProgressCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* window)
  84 {
  85     updateTitle(GTK_WINDOW(window), webView);
  86 }
  87
  88 static void destroyCb(GtkWidget* widget, GtkWidget* window)
  89 {
  90     if (g_atomic_int_dec_and_test(&windowCount))
  91       gtk_main_quit();
  92 }
  93
  94 static void goBackCb(GtkWidget* widget,  WebKitWebView* webView)
  95 {
  96     webkit_web_view_go_back(webView);
  97 }
  98
  99 static void goForwardCb(GtkWidget* widget, WebKitWebView* webView)
 100 {
 101     webkit_web_view_go_forward(webView);
 102 }
 103
 104 static WebKitWebView*
 105 createWebViewCb(WebKitWebView* webView, WebKitWebFrame* web_frame, GtkWidget* window)
 106 {
 107     WebKitWebView *newWebView;
 108     createWindow(&newWebView);
 109     webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
 110     return newWebView;
 111 }
 112
 113 static gboolean webViewReadyCb(WebKitWebView* webView, GtkWidget* window)
 114 {
 115     gtk_widget_grab_focus(GTK_WIDGET(webView));
 116     gtk_widget_show_all(window);
 117     return FALSE;
 118 }
 119
 120 static gboolean closeWebViewCb(WebKitWebView* webView, GtkWidget* window)
 121 {
 122     gtk_widget_destroy(window);
 123     return TRUE;
 124 }
 125
 126 static gboolean webViewFullscreenMessageWindowClose(GtkWidget *dialog)
 127 {
 128     if (GTK_IS_WIDGET(dialog))
 129         gtk_widget_destroy(dialog);
 130     return FALSE;
 131 }
 132
 133 static gboolean webViewWindowStateEvent(GtkWidget *widget, GdkEventWindowState *event, WebKitWebView *webView)
 134 {
 135     if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
 136         WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
 137         const gchar *uri = webkit_web_frame_get_uri(frame);
 138         GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
 139         if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
 140             window = 0;
 141
 142         GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
 143                                                     GTK_DIALOG_MODAL,
 144                                                     GTK_MESSAGE_INFO,
 145                                                     GTK_BUTTONS_CLOSE,
 146                                                     "%s is now full screen. Press ESC or f to exit.", uri);
 147         g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
 148         g_timeout_add(1500, (GSourceFunc) webViewFullscreenMessageWindowClose, dialog);
 149         gtk_dialog_run(GTK_DIALOG(dialog));
 150     }
 151     return TRUE;
 152 }
 153
 154 static void hideWidget(GtkWidget* widget, gpointer data)
 155 {
 156     if (!GTK_IS_SCROLLED_WINDOW(widget))
 157         gtk_widget_hide(widget);
 158 }
 159
 160 static void showWidget(GtkWidget* widget, gpointer data)
 161 {
 162     if (!GTK_IS_SCROLLED_WINDOW(widget))
 163         gtk_widget_show(widget);
 164 }
 165
 166 static gboolean webViewEnteringFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
 167 {
 168     WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
 169     const gchar *uri = webkit_web_frame_get_uri(frame);
 170     GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
 171     if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
 172         window = 0;
 173
 174     GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
 175                                                GTK_DIALOG_MODAL,
 176                                                GTK_MESSAGE_INFO,
 177                                                GTK_BUTTONS_YES_NO,
 178                                                "Allow full screen display of %s ?", uri);
 179     gint result = gtk_dialog_run(GTK_DIALOG(dialog));
 180     if (result == GTK_RESPONSE_YES) {
 181         gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) hideWidget, NULL);
 182         gtk_widget_destroy(GTK_WIDGET(dialog));
 183         return FALSE;
 184     }
 185     gtk_widget_destroy(GTK_WIDGET(dialog));
 186     return TRUE;
 187 }
 188
 189 static gboolean webViewLeavingFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
 190 {
 191     GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
 192     if (gtk_widget_is_toplevel(window) && GTK_IS_WINDOW(window) && !GTK_IS_OFFSCREEN_WINDOW(window))
 193         g_signal_handlers_disconnect_by_func(window, G_CALLBACK(webViewWindowStateEvent), webView);
 194     gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) showWidget, NULL);
 195     return FALSE;
 196 }
 197
 198 static GtkWidget* createBrowser(GtkWidget* window, GtkWidget* uriEntry, GtkWidget* statusbar, WebKitWebView* webView, GtkWidget* vbox)
 199 {
 200     GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
 201     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 202
 203     gtk_container_add(GTK_CONTAINER(scrolledWindow), GTK_WIDGET(webView));
 204
 205     g_signal_connect(webView, "notify::title", G_CALLBACK(notifyTitleCb), window);
 206     g_signal_connect(webView, "notify::load-status", G_CALLBACK(notifyLoadStatusCb), uriEntry);
 207     g_signal_connect(webView, "notify::progress", G_CALLBACK(notifyProgressCb), window);
 208     g_signal_connect(webView, "hovering-over-link", G_CALLBACK(linkHoverCb), statusbar);
 209     g_signal_connect(webView, "create-web-view", G_CALLBACK(createWebViewCb), window);
 210     g_signal_connect(webView, "web-view-ready", G_CALLBACK(webViewReadyCb), window);
 211     g_signal_connect(webView, "close-web-view", G_CALLBACK(closeWebViewCb), window);
 212     g_signal_connect(webView, "entering-fullscreen", G_CALLBACK(webViewEnteringFullScreen), vbox);
 213     g_signal_connect(webView, "leaving-fullscreen", G_CALLBACK(webViewLeavingFullScreen), vbox);
 214
 215     return scrolledWindow;
 216 }
 217
 218 static GtkWidget* createStatusbar()
 219 {
 220     GtkStatusbar *statusbar = GTK_STATUSBAR(gtk_statusbar_new());
 221     guint statusContextId = gtk_statusbar_get_context_id(statusbar, "Link Hover");
 222     g_object_set_data(G_OBJECT(statusbar), "link-hover-context",
 223         GUINT_TO_POINTER(statusContextId));
 224
 225     return GTK_WIDGET(statusbar);
 226 }
 227
 228 static GtkWidget* createToolbar(GtkWidget* uriEntry, WebKitWebView* webView)
 229 {
 230     GtkWidget *toolbar = gtk_toolbar_new();
 231
 232 #if GTK_CHECK_VERSION(2, 15, 0)
 233     gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
 234 #else
 235     gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
 236 #endif
 237     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
 238
 239     GtkToolItem *item;
 240
 241     /* the back button */
 242     item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
 243     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(goBackCb), webView);
 244     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
 245
 246     /* The forward button */
 247     item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
 248     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(goForwardCb), webView);
 249     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
 250
 251     /* The URL entry */
 252     item = gtk_tool_item_new();
 253     gtk_tool_item_set_expand(item, TRUE);
 254     gtk_container_add(GTK_CONTAINER(item), uriEntry);
 255     g_signal_connect(G_OBJECT(uriEntry), "activate", G_CALLBACK(activateUriEntryCb), NULL);
 256     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
 257
 258     /* The go button */
 259     g_object_set_data(G_OBJECT(uriEntry), "web-view", webView);
 260     item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
 261     g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(activateUriEntryCb), (gpointer)uriEntry);
 262     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
 263
 264     return toolbar;
 265 }
 266
 267 static GtkWidget* createWindow(WebKitWebView** outWebView)
 268 {
 269     WebKitWebView *webView;
 270     GtkWidget *vbox;
 271     GtkWidget *window;
 272     GtkWidget *uriEntry;
 273     GtkWidget *statusbar;
 274
 275     g_atomic_int_inc(&windowCount);
 276
 277     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 278     gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
 279     gtk_widget_set_name(window, "GtkLauncher");
 280
 281     webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
 282     uriEntry = gtk_entry_new();
 283
 284 #ifdef GTK_API_VERSION_2
 285     vbox = gtk_vbox_new(FALSE, 0);
 286 #else
 287     vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 288 #endif
 289     statusbar = createStatusbar(webView);
 290     gtk_box_pack_start(GTK_BOX(vbox), createToolbar(uriEntry, webView), FALSE, FALSE, 0);
 291     gtk_box_pack_start(GTK_BOX(vbox), createBrowser(window, uriEntry, statusbar, webView, vbox), TRUE, TRUE, 0);
 292     gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
 293
 294     gtk_container_add(GTK_CONTAINER(window), vbox);
 295
 296     g_signal_connect(window, "destroy", G_CALLBACK(destroyCb), NULL);
 297
 298     if (outWebView)
 299         *outWebView = webView;
 300
 301     return window;
 302 }
 303
 304 static gchar* filenameToURL(const char* filename)
 305 {
 306     if (!g_file_test(filename, G_FILE_TEST_EXISTS))
 307         return NULL;
 308
 309     GFile *gfile = g_file_new_for_path(filename);
 310     gchar *fileURL = g_file_get_uri(gfile);
 311     g_object_unref(gfile);
 312
 313     return fileURL;
 314 }
 315
 316 static gboolean parseOptionEntryCallback(const gchar *optionNameFull, const gchar *value, WebKitWebSettings *webSettings, GError **error)
 317 {
 318     if (strlen(optionNameFull) <= 2) {
 319         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Invalid option %s", optionNameFull);
 320         return FALSE;
 321     }
 322
 323     /* We have two -- in option name so remove them. */
 324     const gchar *optionName = optionNameFull + 2;
 325     GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(webSettings), optionName);
 326     if (!spec) {
 327         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Cannot find web settings for option %s", optionNameFull);
 328         return FALSE;
 329     }
 330
 331     switch (G_PARAM_SPEC_VALUE_TYPE(spec)) {
 332     case G_TYPE_BOOLEAN: {
 333         gboolean propertyValue = TRUE;
 334         if (value && g_ascii_strcasecmp(value, "true") && strcmp(value, "1"))
 335             propertyValue = FALSE;
 336         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
 337         break;
 338     }
 339     case G_TYPE_STRING:
 340         g_object_set(G_OBJECT(webSettings), optionName, value, NULL);
 341         break;
 342     case G_TYPE_INT: {
 343         glong propertyValue;
 344         gchar *end;
 345
 346         errno = 0;
 347         propertyValue = g_ascii_strtoll(value, &end, 0);
 348         if (errno == ERANGE || propertyValue > G_MAXINT || propertyValue < G_MININT) {
 349             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Integer value '%s' for %s out of range", value, optionNameFull);
 350             return FALSE;
 351         }
 352         if (errno || value == end) {
 353             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse integer value '%s' for %s", value, optionNameFull);
 354             return FALSE;
 355         }
 356         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
 357         break;
 358     }
 359     case G_TYPE_FLOAT: {
 360         gdouble propertyValue;
 361         gchar *end;
 362
 363         errno = 0;
 364         propertyValue = g_ascii_strtod(value, &end);
 365         if (errno == ERANGE || propertyValue > G_MAXFLOAT || propertyValue < G_MINFLOAT) {
 366             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Float value '%s' for %s out of range", value, optionNameFull);
 367             return FALSE;
 368         }
 369         if (errno || value == end) {
 370             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse float value '%s' for %s", value, optionNameFull);
 371             return FALSE;
 372         }
 373         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
 374         break;
 375     }
 376     default:
 377         g_assert_not_reached();
 378     }
 379
 380     return TRUE;
 381 }
 382
 383 static gboolean isValidParameterType(GType gParamType)
 384 {
 385     return (gParamType == G_TYPE_BOOLEAN || gParamType == G_TYPE_STRING || gParamType == G_TYPE_INT
 386             || gParamType == G_TYPE_FLOAT);
 387 }
 388
 389 static GOptionEntry* getOptionEntriesFromWebKitWebSettings(WebKitWebSettings *webSettings)
 390 {
 391     GParamSpec **propertySpecs;
 392     GOptionEntry *optionEntries;
 393     guint numProperties, numEntries, i;
 394
 395     propertySpecs = g_object_class_list_properties(G_OBJECT_GET_CLASS(webSettings), &numProperties);
 396     if (!propertySpecs)
 397         return NULL;
 398
 399     optionEntries = g_new0(GOptionEntry, numProperties + 1);
 400     numEntries = 0;
 401     for (i = 0; i < numProperties; i++) {
 402         GParamSpec *param = propertySpecs[i];
 403
 404         /* Fill in structures only for writable and not construct-only properties. */
 405         if (!param || !(param->flags & G_PARAM_WRITABLE) || (param->flags & G_PARAM_CONSTRUCT_ONLY))
 406             continue;
 407
 408         GType gParamType = G_PARAM_SPEC_VALUE_TYPE(param);
 409         if (!isValidParameterType(gParamType))
 410             continue;
 411
 412         GOptionEntry *optionEntry = &optionEntries[numEntries++];
 413         optionEntry->long_name = g_param_spec_get_name(param);
 414
 415         /* There is no easy way to figure our short name for generated option entries.
 416            optionEntry.short_name=*/
 417         /* For bool arguments "enable" type make option argument not required. */
 418         if (gParamType == G_TYPE_BOOLEAN && (strstr(optionEntry->long_name, "enable")))
 419             optionEntry->flags = G_OPTION_FLAG_OPTIONAL_ARG;
 420         optionEntry->arg = G_OPTION_ARG_CALLBACK;
 421         optionEntry->arg_data = parseOptionEntryCallback;
 422         optionEntry->description = g_param_spec_get_blurb(param);
 423         optionEntry->arg_description = g_type_name(gParamType);
 424     }
 425     g_free(propertySpecs);
 426
 427     return optionEntries;
 428 }
 429
 430 static gboolean addWebSettingsGroupToContext(GOptionContext *context, WebKitWebSettings* webkitSettings)
 431 {
 432     GOptionEntry *optionEntries = getOptionEntriesFromWebKitWebSettings(webkitSettings);
 433     if (!optionEntries)
 434         return FALSE;
 435
 436     GOptionGroup *webSettingsGroup = g_option_group_new("websettings",
 437                                                         "WebKitWebSettings writable properties for default WebKitWebView",
 438                                                         "WebKitWebSettings properties",
 439                                                         webkitSettings,
 440                                                         NULL);
 441     g_option_group_add_entries(webSettingsGroup, optionEntries);
 442     g_free(optionEntries);
 443
 444     /* Option context takes ownership of the group. */
 445     g_option_context_add_group(context, webSettingsGroup);
 446
 447     return TRUE;
 448 }
 449
 450 int main(int argc, char* argv[])
 451 {
 452     WebKitWebSettings *webkitSettings = 0;
 453     const gchar **uriArguments = 0;
 454     const GOptionEntry commandLineOptions[] =
 455     {
 456         { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL]" },
 457         { 0, 0, 0, 0, 0, 0, 0 }
 458     };
 459
 460     gtk_init(&argc, &argv);
 461
 462     GOptionContext *context = g_option_context_new(0);
 463     g_option_context_add_main_entries(context, commandLineOptions, 0);
 464     g_option_context_add_group(context, gtk_get_option_group(TRUE));
 465
 466     webkitSettings = webkit_web_settings_new();
 467     if (!addWebSettingsGroupToContext(context, webkitSettings)) {
 468         g_object_unref(webkitSettings);
 469         webkitSettings = 0;
 470     }
 471
 472     GError *error = 0;
 473     if (!g_option_context_parse(context, &argc, &argv, &error)) {
 474         g_printerr("Cannot parse arguments: %s\n", error->message);
 475         g_error_free(error);
 476         g_option_context_free(context);
 477
 478         return 1;
 479     }
 480     g_option_context_free(context);
 481
 482 #ifdef SOUP_TYPE_PROXY_RESOLVER_DEFAULT
 483     soup_session_add_feature_by_type(webkit_get_default_session(), SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
 484 #else
 485     const char *httpProxy = g_getenv("http_proxy");
 486     if (httpProxy) {
 487         SoupURI *proxyUri = soup_uri_new(httpProxy);
 488         g_object_set(webkit_get_default_session(), SOUP_SESSION_PROXY_URI, proxyUri, NULL);
 489         soup_uri_free(proxyUri);
 490     }
 491 #endif
 492
 493     WebKitWebView *webView;
 494     GtkWidget *main_window = createWindow(&webView);
 495
 496     if (webkitSettings) {
 497         webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
 498         g_object_unref(webkitSettings);
 499     }
 500
 501     const gchar *uri = (uriArguments ? uriArguments[0] : "http://www.google.com/");
 502     gchar *fileURL = filenameToURL(uri);
 503
 504     webkit_web_view_load_uri(webView, fileURL ? fileURL : uri);
 505     g_free(fileURL);
 506
 507     gtk_widget_grab_focus(GTK_WIDGET(webView));
 508     gtk_widget_show_all(main_window);
 509     gtk_main();
 510
 511     return 0;
 512 }