cbbfed19f1486ddc48f04abd1b8bed74ee5e510e
[WebKit-https.git] / 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 "autotoolsconfig.h"
29 #include "LauncherInspectorWindow.h"
30 #include <errno.h>
31 #include <gdk/gdkkeysyms.h>
32 #ifdef WTF_USE_GSTREAMER
33 #include <gst/gst.h>
34 #endif
35 #include <gtk/gtk.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <webkit/webkit.h>
39
40 static gint windowCount = 0;
41
42 static GtkWidget* createWindow(WebKitWebView** outWebView);
43
44 static void activateUriEntryCb(GtkWidget* entry, gpointer data)
45 {
46     WebKitWebView *webView = g_object_get_data(G_OBJECT(entry), "web-view");
47     const gchar* uri = gtk_entry_get_text(GTK_ENTRY(entry));
48     g_assert(uri);
49     gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(entry), GTK_ENTRY_ICON_PRIMARY, 0);
50     webkit_web_view_load_uri(webView, uri);
51 }
52
53 static void updateTitle(GtkWindow* window, WebKitWebView* webView)
54 {
55     GString *string = g_string_new(webkit_web_view_get_title(webView));
56     gdouble loadProgress = webkit_web_view_get_progress(webView) * 100;
57     g_string_append(string, " - WebKit Launcher");
58     if (loadProgress < 100)
59         g_string_append_printf(string, " (%f%%)", loadProgress);
60     gchar *title = g_string_free(string, FALSE);
61     gtk_window_set_title(window, title);
62     g_free(title);
63 }
64
65 static void linkHoverCb(WebKitWebView* page, const gchar* title, const gchar* link, GtkStatusbar* statusbar)
66 {
67     guint statusContextId =
68       GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(statusbar), "link-hover-context"));
69     /* underflow is allowed */
70     gtk_statusbar_pop(statusbar, statusContextId);
71     if (link)
72         gtk_statusbar_push(statusbar, statusContextId, link);
73 }
74
75 static void notifyTitleCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* window)
76 {
77     updateTitle(GTK_WINDOW(window), webView);
78 }
79
80 static void notifyLoadStatusCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* uriEntry)
81 {
82     if (webkit_web_view_get_load_status(webView) == WEBKIT_LOAD_COMMITTED) {
83         WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
84         const gchar *uri = webkit_web_frame_get_uri(frame);
85         if (uri)
86             gtk_entry_set_text(GTK_ENTRY(uriEntry), uri);
87     }
88 }
89
90 static void notifyProgressCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* window)
91 {
92     updateTitle(GTK_WINDOW(window), webView);
93 }
94
95 static void destroyCb(GtkWidget* widget, GtkWidget* window)
96 {
97     if (g_atomic_int_dec_and_test(&windowCount))
98       gtk_main_quit();
99 }
100
101 static void goBackCb(GtkWidget* widget,  WebKitWebView* webView)
102 {
103     webkit_web_view_go_back(webView);
104 }
105
106 static void goForwardCb(GtkWidget* widget, WebKitWebView* webView)
107 {
108     webkit_web_view_go_forward(webView);
109 }
110
111 static void reloadCb(GtkWidget* widget, WebKitWebView* webView)
112 {
113     webkit_web_view_reload(webView);
114 }
115
116 static WebKitWebView*
117 createWebViewCb(WebKitWebView* webView, WebKitWebFrame* web_frame, GtkWidget* window)
118 {
119     WebKitWebView *newWebView;
120     createWindow(&newWebView);
121     webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
122     return newWebView;
123 }
124
125 static gboolean webViewReadyCb(WebKitWebView* webView, GtkWidget* window)
126 {
127     gtk_widget_grab_focus(GTK_WIDGET(webView));
128     gtk_widget_show_all(window);
129     return FALSE;
130 }
131
132 static gboolean closeWebViewCb(WebKitWebView* webView, GtkWidget* window)
133 {
134     gtk_widget_destroy(window);
135     return TRUE;
136 }
137
138 static gboolean webViewFullscreenMessageWindowClose(GtkWidget *dialog)
139 {
140     if (GTK_IS_WIDGET(dialog))
141         gtk_widget_destroy(dialog);
142     return FALSE;
143 }
144
145 static gboolean webViewWindowStateEvent(GtkWidget *widget, GdkEventWindowState *event, WebKitWebView *webView)
146 {
147     if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) {
148         WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
149         const gchar *uri = webkit_web_frame_get_uri(frame);
150         GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
151         if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
152             window = 0;
153
154         GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
155                                                     GTK_DIALOG_MODAL,
156                                                     GTK_MESSAGE_INFO,
157                                                     GTK_BUTTONS_CLOSE,
158                                                     "%s is now full screen. Press ESC or f to exit.", uri);
159         g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
160         g_timeout_add(1500, (GSourceFunc) webViewFullscreenMessageWindowClose, dialog);
161         gtk_dialog_run(GTK_DIALOG(dialog));
162     }
163     return TRUE;
164 }
165
166 static void hideWidget(GtkWidget* widget, gpointer data)
167 {
168     if (!GTK_IS_SCROLLED_WINDOW(widget))
169         gtk_widget_hide(widget);
170 }
171
172 static void showWidget(GtkWidget* widget, gpointer data)
173 {
174     if (!GTK_IS_SCROLLED_WINDOW(widget))
175         gtk_widget_show(widget);
176 }
177
178 static gboolean webViewEnteringFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
179 {
180     WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
181     const gchar *uri = webkit_web_frame_get_uri(frame);
182     GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
183     if (!gtk_widget_is_toplevel(window) || !GTK_IS_WINDOW(window) || GTK_IS_OFFSCREEN_WINDOW(window))
184         window = 0;
185
186     GtkWidget *dialog = gtk_message_dialog_new(window ? GTK_WINDOW(window) : 0,
187                                                GTK_DIALOG_MODAL,
188                                                GTK_MESSAGE_INFO,
189                                                GTK_BUTTONS_YES_NO,
190                                                "Allow full screen display of %s ?", uri);
191     gint result = gtk_dialog_run(GTK_DIALOG(dialog));
192     if (result == GTK_RESPONSE_YES) {
193         gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) hideWidget, NULL);
194         gtk_widget_destroy(GTK_WIDGET(dialog));
195         return FALSE;
196     }
197     gtk_widget_destroy(GTK_WIDGET(dialog));
198     return TRUE;
199 }
200
201 static gboolean webViewLeavingFullScreen(WebKitWebView *webView, GObject *element, GtkWidget* vbox)
202 {
203     GtkWidget *window = gtk_widget_get_toplevel(GTK_WIDGET(webView));
204     if (gtk_widget_is_toplevel(window) && GTK_IS_WINDOW(window) && !GTK_IS_OFFSCREEN_WINDOW(window))
205         g_signal_handlers_disconnect_by_func(window, G_CALLBACK(webViewWindowStateEvent), webView);
206     gtk_container_foreach(GTK_CONTAINER(vbox), (GtkCallback) showWidget, NULL);
207     return FALSE;
208 }
209
210 static void iconLoadedCb(WebKitWebView* webView, const char* iconURI, GtkWidget* uriEntry)
211 {
212     GdkPixbuf *icon = webkit_web_view_try_get_favicon_pixbuf(webView, 16, 16);
213     if (!icon)
214         return;
215
216     gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(uriEntry), GTK_ENTRY_ICON_PRIMARY, icon);
217     g_object_unref(icon);
218 }
219
220 static GtkWidget *inspectorInspectWebViewCb(WebKitWebInspector *inspector, WebKitWebView *webView, GtkWindow* window)
221 {
222     GtkWidget *inspectorWindow = launcherInspectorWindowNew(inspector, window);
223     return GTK_WIDGET(launcherInspectorWindowGetWebView(LAUNCHER_INSPECTOR_WINDOW(inspectorWindow)));
224 }
225
226 static GtkWidget* createBrowser(GtkWidget* window, GtkWidget* uriEntry, GtkWidget* statusbar, WebKitWebView* webView, GtkWidget* vbox)
227 {
228     char *iconDatabasePath;
229     GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
230     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
231
232     gtk_container_add(GTK_CONTAINER(scrolledWindow), GTK_WIDGET(webView));
233
234     iconDatabasePath = g_build_filename(g_get_user_data_dir(), "webkit", "icondatabase", NULL);
235     webkit_favicon_database_set_path(webkit_get_favicon_database(), iconDatabasePath);
236     g_free(iconDatabasePath);
237
238     g_signal_connect(webView, "notify::title", G_CALLBACK(notifyTitleCb), window);
239     g_signal_connect(webView, "notify::load-status", G_CALLBACK(notifyLoadStatusCb), uriEntry);
240     g_signal_connect(webView, "notify::progress", G_CALLBACK(notifyProgressCb), window);
241     g_signal_connect(webView, "icon-loaded", G_CALLBACK(iconLoadedCb), uriEntry);
242     g_signal_connect(webView, "hovering-over-link", G_CALLBACK(linkHoverCb), statusbar);
243     g_signal_connect(webView, "create-web-view", G_CALLBACK(createWebViewCb), window);
244     g_signal_connect(webView, "web-view-ready", G_CALLBACK(webViewReadyCb), window);
245     g_signal_connect(webView, "close-web-view", G_CALLBACK(closeWebViewCb), window);
246     g_signal_connect(webView, "entering-fullscreen", G_CALLBACK(webViewEnteringFullScreen), vbox);
247     g_signal_connect(webView, "leaving-fullscreen", G_CALLBACK(webViewLeavingFullScreen), vbox);
248     g_signal_connect(webkit_web_view_get_inspector(webView), "inspect-web-view", G_CALLBACK(inspectorInspectWebViewCb), window);
249
250     return scrolledWindow;
251 }
252
253 static GtkWidget* createStatusbar()
254 {
255     GtkStatusbar *statusbar = GTK_STATUSBAR(gtk_statusbar_new());
256     guint statusContextId = gtk_statusbar_get_context_id(statusbar, "Link Hover");
257     g_object_set_data(G_OBJECT(statusbar), "link-hover-context",
258         GUINT_TO_POINTER(statusContextId));
259
260     return GTK_WIDGET(statusbar);
261 }
262
263 static GtkWidget* createToolbar(GtkWidget* window, GtkWidget* uriEntry, WebKitWebView* webView)
264 {
265     GtkWidget *toolbar = gtk_toolbar_new();
266
267     gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
268     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
269
270     GtkToolItem *item;
271
272     /* Keyboard accelerators */
273     GtkAccelGroup *accelGroup = gtk_accel_group_new();
274     gtk_window_add_accel_group(GTK_WINDOW(window), accelGroup);
275
276     /* the back button */
277     item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
278     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(goBackCb), webView);
279     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
280
281     /* The forward button */
282     item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
283     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(goForwardCb), webView);
284     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
285
286     /* The reload button */
287     item = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
288     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(reloadCb), webView);
289     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
290     gtk_widget_add_accelerator(GTK_WIDGET(item), "clicked", accelGroup, GDK_KEY_F5, 0, GTK_ACCEL_VISIBLE);
291
292     /* The URL entry */
293     item = gtk_tool_item_new();
294     gtk_tool_item_set_expand(item, TRUE);
295     gtk_container_add(GTK_CONTAINER(item), uriEntry);
296     g_signal_connect(G_OBJECT(uriEntry), "activate", G_CALLBACK(activateUriEntryCb), NULL);
297     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
298
299     /* The go button */
300     g_object_set_data(G_OBJECT(uriEntry), "web-view", webView);
301     item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
302     g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(activateUriEntryCb), (gpointer)uriEntry);
303     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
304
305     return toolbar;
306 }
307
308 static GtkWidget* createWindow(WebKitWebView** outWebView)
309 {
310     WebKitWebView *webView;
311     GtkWidget *vbox;
312     GtkWidget *window;
313     GtkWidget *uriEntry;
314     GtkWidget *statusbar;
315
316     g_atomic_int_inc(&windowCount);
317
318     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
319     gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
320     gtk_widget_set_name(window, "GtkLauncher");
321
322     webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
323     uriEntry = gtk_entry_new();
324
325 #ifdef GTK_API_VERSION_2
326     vbox = gtk_vbox_new(FALSE, 0);
327 #else
328     vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
329 #endif
330     statusbar = createStatusbar(webView);
331     gtk_box_pack_start(GTK_BOX(vbox), createToolbar(window, uriEntry, webView), FALSE, FALSE, 0);
332     gtk_box_pack_start(GTK_BOX(vbox), createBrowser(window, uriEntry, statusbar, webView, vbox), TRUE, TRUE, 0);
333     gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
334
335     gtk_container_add(GTK_CONTAINER(window), vbox);
336
337     g_signal_connect(window, "destroy", G_CALLBACK(destroyCb), NULL);
338
339     if (outWebView)
340         *outWebView = webView;
341
342     return window;
343 }
344
345 static gchar* filenameToURL(const char* filename)
346 {
347     if (!g_file_test(filename, G_FILE_TEST_EXISTS))
348         return NULL;
349
350     GFile *gfile = g_file_new_for_path(filename);
351     gchar *fileURL = g_file_get_uri(gfile);
352     g_object_unref(gfile);
353
354     return fileURL;
355 }
356
357 static gboolean parseOptionEntryCallback(const gchar *optionNameFull, const gchar *value, WebKitWebSettings *webSettings, GError **error)
358 {
359     if (strlen(optionNameFull) <= 2) {
360         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Invalid option %s", optionNameFull);
361         return FALSE;
362     }
363
364     /* We have two -- in option name so remove them. */
365     const gchar *optionName = optionNameFull + 2;
366     GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(webSettings), optionName);
367     if (!spec) {
368         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Cannot find web settings for option %s", optionNameFull);
369         return FALSE;
370     }
371
372     switch (G_PARAM_SPEC_VALUE_TYPE(spec)) {
373     case G_TYPE_BOOLEAN: {
374         gboolean propertyValue = TRUE;
375         if (value && g_ascii_strcasecmp(value, "true") && strcmp(value, "1"))
376             propertyValue = FALSE;
377         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
378         break;
379     }
380     case G_TYPE_STRING:
381         g_object_set(G_OBJECT(webSettings), optionName, value, NULL);
382         break;
383     case G_TYPE_INT: {
384         glong propertyValue;
385         gchar *end;
386
387         errno = 0;
388         propertyValue = g_ascii_strtoll(value, &end, 0);
389         if (errno == ERANGE || propertyValue > G_MAXINT || propertyValue < G_MININT) {
390             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Integer value '%s' for %s out of range", value, optionNameFull);
391             return FALSE;
392         }
393         if (errno || value == end) {
394             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse integer value '%s' for %s", value, optionNameFull);
395             return FALSE;
396         }
397         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
398         break;
399     }
400     case G_TYPE_FLOAT: {
401         gdouble propertyValue;
402         gchar *end;
403
404         errno = 0;
405         propertyValue = g_ascii_strtod(value, &end);
406         if (errno == ERANGE || propertyValue > G_MAXFLOAT || propertyValue < G_MINFLOAT) {
407             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Float value '%s' for %s out of range", value, optionNameFull);
408             return FALSE;
409         }
410         if (errno || value == end) {
411             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse float value '%s' for %s", value, optionNameFull);
412             return FALSE;
413         }
414         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
415         break;
416     }
417     default:
418         g_assert_not_reached();
419     }
420
421     return TRUE;
422 }
423
424 static gboolean isValidParameterType(GType gParamType)
425 {
426     return (gParamType == G_TYPE_BOOLEAN || gParamType == G_TYPE_STRING || gParamType == G_TYPE_INT
427             || gParamType == G_TYPE_FLOAT);
428 }
429
430 static GOptionEntry* getOptionEntriesFromWebKitWebSettings(WebKitWebSettings *webSettings)
431 {
432     GParamSpec **propertySpecs;
433     GOptionEntry *optionEntries;
434     guint numProperties, numEntries, i;
435
436     propertySpecs = g_object_class_list_properties(G_OBJECT_GET_CLASS(webSettings), &numProperties);
437     if (!propertySpecs)
438         return NULL;
439
440     optionEntries = g_new0(GOptionEntry, numProperties + 1);
441     numEntries = 0;
442     for (i = 0; i < numProperties; i++) {
443         GParamSpec *param = propertySpecs[i];
444
445         /* Fill in structures only for writable and not construct-only properties. */
446         if (!param || !(param->flags & G_PARAM_WRITABLE) || (param->flags & G_PARAM_CONSTRUCT_ONLY))
447             continue;
448
449         GType gParamType = G_PARAM_SPEC_VALUE_TYPE(param);
450         if (!isValidParameterType(gParamType))
451             continue;
452
453         GOptionEntry *optionEntry = &optionEntries[numEntries++];
454         optionEntry->long_name = g_param_spec_get_name(param);
455
456         /* There is no easy way to figure our short name for generated option entries.
457            optionEntry.short_name=*/
458         /* For bool arguments "enable" type make option argument not required. */
459         if (gParamType == G_TYPE_BOOLEAN && (strstr(optionEntry->long_name, "enable")))
460             optionEntry->flags = G_OPTION_FLAG_OPTIONAL_ARG;
461         optionEntry->arg = G_OPTION_ARG_CALLBACK;
462         optionEntry->arg_data = parseOptionEntryCallback;
463         optionEntry->description = g_param_spec_get_blurb(param);
464         optionEntry->arg_description = g_type_name(gParamType);
465     }
466     g_free(propertySpecs);
467
468     return optionEntries;
469 }
470
471 static gboolean addWebSettingsGroupToContext(GOptionContext *context, WebKitWebSettings* webkitSettings)
472 {
473     GOptionEntry *optionEntries = getOptionEntriesFromWebKitWebSettings(webkitSettings);
474     if (!optionEntries)
475         return FALSE;
476
477     GOptionGroup *webSettingsGroup = g_option_group_new("websettings",
478                                                         "WebKitWebSettings writable properties for default WebKitWebView",
479                                                         "WebKitWebSettings properties",
480                                                         webkitSettings,
481                                                         NULL);
482     g_option_group_add_entries(webSettingsGroup, optionEntries);
483     g_free(optionEntries);
484
485     /* Option context takes ownership of the group. */
486     g_option_context_add_group(context, webSettingsGroup);
487
488     return TRUE;
489 }
490
491 int main(int argc, char* argv[])
492 {
493     WebKitWebSettings *webkitSettings = 0;
494     const gchar **uriArguments = 0;
495     const GOptionEntry commandLineOptions[] =
496     {
497         { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL]" },
498         { 0, 0, 0, 0, 0, 0, 0 }
499     };
500
501     gtk_init(&argc, &argv);
502
503     GOptionContext *context = g_option_context_new(0);
504     g_option_context_add_main_entries(context, commandLineOptions, 0);
505     g_option_context_add_group(context, gtk_get_option_group(TRUE));
506 #ifdef WTF_USE_GSTREAMER
507     g_option_context_add_group(context, gst_init_get_option_group());
508 #endif
509     webkitSettings = webkit_web_settings_new();
510     g_object_set(webkitSettings, "enable-developer-extras", TRUE, NULL);
511     if (!addWebSettingsGroupToContext(context, webkitSettings)) {
512         g_object_unref(webkitSettings);
513         webkitSettings = 0;
514     }
515
516     GError *error = 0;
517     if (!g_option_context_parse(context, &argc, &argv, &error)) {
518         g_printerr("Cannot parse arguments: %s\n", error->message);
519         g_error_free(error);
520         g_option_context_free(context);
521
522         return 1;
523     }
524     g_option_context_free(context);
525
526 #ifdef SOUP_TYPE_PROXY_RESOLVER_DEFAULT
527     soup_session_add_feature_by_type(webkit_get_default_session(), SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
528 #else
529     const char *httpProxy = g_getenv("http_proxy");
530     if (httpProxy) {
531         SoupURI *proxyUri = soup_uri_new(httpProxy);
532         g_object_set(webkit_get_default_session(), SOUP_SESSION_PROXY_URI, proxyUri, NULL);
533         soup_uri_free(proxyUri);
534     }
535 #endif
536
537     WebKitWebView *webView;
538     GtkWidget *main_window = createWindow(&webView);
539
540     if (webkitSettings) {
541         webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
542         g_object_unref(webkitSettings);
543     }
544
545     const gchar *uri = (uriArguments ? uriArguments[0] : "http://www.google.com/");
546     gchar *fileURL = filenameToURL(uri);
547
548     webkit_web_view_load_uri(webView, fileURL ? fileURL : uri);
549     g_free(fileURL);
550
551     gtk_widget_grab_focus(GTK_WIDGET(webView));
552     gtk_widget_show_all(main_window);
553     gtk_main();
554
555     return 0;
556 }