Add static version of JSCell::getConstructData
[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 <errno.h>
29 #include <gtk/gtk.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #ifdef WEBKIT2
33 #include <webkit2/webkit2.h>
34 #else
35 #include <webkit/webkit.h>
36 #endif
37
38 static gint windowCount = 0;
39
40 static GtkWidget* createWindow(WebKitWebView** outWebView);
41
42 static void activateUriEntryCb(GtkWidget* entry, gpointer data)
43 {
44     WebKitWebView *webView = g_object_get_data(G_OBJECT(entry), "web-view");
45     const gchar* uri = gtk_entry_get_text(GTK_ENTRY(entry));
46     g_assert(uri);
47     webkit_web_view_load_uri(webView, uri);
48 }
49
50 #ifndef WEBKIT2
51 static void updateTitle(GtkWindow* window, WebKitWebView* webView)
52 {
53     GString *string = g_string_new(webkit_web_view_get_title(webView));
54     gdouble loadProgress = webkit_web_view_get_progress(webView) * 100;
55     g_string_append(string, " - WebKit Launcher");
56     if (loadProgress < 100)
57         g_string_append_printf(string, " (%f%%)", loadProgress);
58     gchar *title = g_string_free(string, FALSE);
59     gtk_window_set_title(window, title);
60     g_free(title);
61 }
62
63 static void linkHoverCb(WebKitWebView* page, const gchar* title, const gchar* link, GtkStatusbar* statusbar)
64 {
65     guint statusContextId =
66       GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(statusbar), "link-hover-context"));
67     /* underflow is allowed */
68     gtk_statusbar_pop(statusbar, statusContextId);
69     if (link)
70         gtk_statusbar_push(statusbar, statusContextId, link);
71 }
72
73 static void notifyTitleCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* window)
74 {
75     updateTitle(GTK_WINDOW(window), webView);
76 }
77
78 static void notifyLoadStatusCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* uriEntry)
79 {
80     if (webkit_web_view_get_load_status(webView) == WEBKIT_LOAD_COMMITTED) {
81         WebKitWebFrame *frame = webkit_web_view_get_main_frame(webView);
82         const gchar *uri = webkit_web_frame_get_uri(frame);
83         if (uri)
84             gtk_entry_set_text(GTK_ENTRY(uriEntry), uri);
85     }
86 }
87
88 static void notifyProgressCb(WebKitWebView* webView, GParamSpec* pspec, GtkWidget* window)
89 {
90     updateTitle(GTK_WINDOW(window), webView);
91 }
92 #endif
93
94 static void destroyCb(GtkWidget* widget, GtkWidget* window)
95 {
96     if (g_atomic_int_dec_and_test(&windowCount))
97       gtk_main_quit();
98 }
99
100 static void goBackCb(GtkWidget* widget,  WebKitWebView* webView)
101 {
102     webkit_web_view_go_back(webView);
103 }
104
105 static void goForwardCb(GtkWidget* widget, WebKitWebView* webView)
106 {
107     webkit_web_view_go_forward(webView);
108 }
109
110 #ifndef WEBKIT2
111 static WebKitWebView*
112 createWebViewCb(WebKitWebView* webView, WebKitWebFrame* web_frame, GtkWidget* window)
113 {
114     WebKitWebView *newWebView;
115     createWindow(&newWebView);
116     webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
117     return newWebView;
118 }
119
120 static gboolean webViewReadyCb(WebKitWebView* webView, GtkWidget* window)
121 {
122     gtk_widget_grab_focus(GTK_WIDGET(webView));
123     gtk_widget_show_all(window);
124     return FALSE;
125 }
126
127 static gboolean closeWebViewCb(WebKitWebView* webView, GtkWidget* window)
128 {
129     gtk_widget_destroy(window);
130     return TRUE;
131 }
132 #endif
133
134 static GtkWidget* createBrowser(GtkWidget* window, GtkWidget* uriEntry, GtkWidget* statusbar, WebKitWebView* webView)
135 {
136     GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
137     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
138
139     gtk_container_add(GTK_CONTAINER(scrolledWindow), GTK_WIDGET(webView));
140
141 #ifndef WEBKIT2
142     g_signal_connect(webView, "notify::title", G_CALLBACK(notifyTitleCb), window);
143     g_signal_connect(webView, "notify::load-status", G_CALLBACK(notifyLoadStatusCb), uriEntry);
144     g_signal_connect(webView, "notify::progress", G_CALLBACK(notifyProgressCb), window);
145     g_signal_connect(webView, "hovering-over-link", G_CALLBACK(linkHoverCb), statusbar);
146     g_signal_connect(webView, "create-web-view", G_CALLBACK(createWebViewCb), window);
147     g_signal_connect(webView, "web-view-ready", G_CALLBACK(webViewReadyCb), window);
148     g_signal_connect(webView, "close-web-view", G_CALLBACK(closeWebViewCb), window);
149 #endif
150
151     return scrolledWindow;
152 }
153
154 static GtkWidget* createStatusbar()
155 {
156     GtkStatusbar *statusbar = GTK_STATUSBAR(gtk_statusbar_new());
157     guint statusContextId = gtk_statusbar_get_context_id(statusbar, "Link Hover");
158     g_object_set_data(G_OBJECT(statusbar), "link-hover-context",
159         GUINT_TO_POINTER(statusContextId));
160
161     return GTK_WIDGET(statusbar);
162 }
163
164 static GtkWidget* createToolbar(GtkWidget* uriEntry, WebKitWebView* webView)
165 {
166     GtkWidget *toolbar = gtk_toolbar_new();
167
168 #if GTK_CHECK_VERSION(2, 15, 0)
169     gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
170 #else
171     gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
172 #endif
173     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
174
175     GtkToolItem *item;
176
177     /* the back button */
178     item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
179     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(goBackCb), webView);
180     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
181
182     /* The forward button */
183     item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
184     g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(goForwardCb), webView);
185     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
186
187     /* The URL entry */
188     item = gtk_tool_item_new();
189     gtk_tool_item_set_expand(item, TRUE);
190     gtk_container_add(GTK_CONTAINER(item), uriEntry);
191     g_signal_connect(G_OBJECT(uriEntry), "activate", G_CALLBACK(activateUriEntryCb), NULL);
192     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
193
194     /* The go button */
195     g_object_set_data(G_OBJECT(uriEntry), "web-view", webView);
196     item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
197     g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(activateUriEntryCb), (gpointer)uriEntry);
198     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
199
200     return toolbar;
201 }
202
203 static GtkWidget* createWindow(WebKitWebView** outWebView)
204 {
205     WebKitWebView *webView;
206     GtkWidget *vbox;
207     GtkWidget *window;
208     GtkWidget *uriEntry;
209     GtkWidget *statusbar;
210
211     g_atomic_int_inc(&windowCount);
212
213     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
214     gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
215     gtk_widget_set_name(window, "GtkLauncher");
216
217     webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
218     uriEntry = gtk_entry_new();
219
220 #ifdef GTK_API_VERSION_2
221     vbox = gtk_vbox_new(FALSE, 0);
222 #else
223     vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
224 #endif
225     statusbar = createStatusbar(webView);
226     gtk_box_pack_start(GTK_BOX(vbox), createToolbar(uriEntry, webView), FALSE, FALSE, 0);
227     gtk_box_pack_start(GTK_BOX(vbox), createBrowser(window, uriEntry, statusbar, webView), TRUE, TRUE, 0);
228     gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
229
230     gtk_container_add(GTK_CONTAINER(window), vbox);
231
232     g_signal_connect(window, "destroy", G_CALLBACK(destroyCb), NULL);
233
234     if (outWebView)
235         *outWebView = webView;
236
237     return window;
238 }
239
240 static gchar* filenameToURL(const char* filename)
241 {
242     if (!g_file_test(filename, G_FILE_TEST_EXISTS))
243         return 0;
244
245     GFile *gfile = g_file_new_for_path(filename);
246     gchar *fileURL = g_file_get_uri(gfile);
247     g_object_unref(gfile);
248
249     return fileURL;
250 }
251
252 #ifndef WEBKIT2
253 static gboolean parseOptionEntryCallback(const gchar *optionNameFull, const gchar *value, WebKitWebSettings *webSettings, GError **error)
254 {
255     if (strlen(optionNameFull) <= 2) {
256         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Invalid option %s", optionNameFull);
257         return FALSE;
258     }
259
260     /* We have two -- in option name so remove them. */
261     const gchar *optionName = optionNameFull + 2;
262     GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(webSettings), optionName);
263     if (!spec) {
264         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Cannot find web settings for option %s", optionNameFull);
265         return FALSE;
266     }
267
268     switch (G_PARAM_SPEC_VALUE_TYPE(spec)) {
269     case G_TYPE_BOOLEAN: {
270         gboolean propertyValue = TRUE;
271         if (value && g_ascii_strcasecmp(value, "true") && strcmp(value, "1"))
272             propertyValue = FALSE;
273         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
274         break;
275     }
276     case G_TYPE_STRING:
277         g_object_set(G_OBJECT(webSettings), optionName, value, NULL);
278         break;
279     case G_TYPE_INT: {
280         glong propertyValue;
281         gchar *end;
282
283         errno = 0;
284         propertyValue = g_ascii_strtoll(value, &end, 0);
285         if (errno == ERANGE || propertyValue > G_MAXINT || propertyValue < G_MININT) {
286             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Integer value '%s' for %s out of range", value, optionNameFull);
287             return FALSE;
288         }
289         if (errno || value == end) {
290             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse integer value '%s' for %s", value, optionNameFull);
291             return FALSE;
292         }
293         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
294         break;
295     }
296     case G_TYPE_FLOAT: {
297         gdouble propertyValue;
298         gchar *end;
299
300         errno = 0;
301         propertyValue = g_ascii_strtod(value, &end);
302         if (errno == ERANGE || propertyValue > G_MAXFLOAT || propertyValue < G_MINFLOAT) {
303             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Float value '%s' for %s out of range", value, optionNameFull);
304             return FALSE;
305         }
306         if (errno || value == end) {
307             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse float value '%s' for %s", value, optionNameFull);
308             return FALSE;
309         }
310         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
311         break;
312     }
313     default:
314         g_assert_not_reached();
315     }
316
317     return TRUE;
318 }
319
320 static GOptionEntry* getOptionEntriesFromWebKitWebSettings(WebKitWebSettings *webSettings)
321 {
322     GParamSpec **propertySpecs;
323     GOptionEntry *optionEntries;
324     guint numProperties, numEntries, i;
325
326     propertySpecs = g_object_class_list_properties(G_OBJECT_GET_CLASS(webSettings), &numProperties);
327     if (!propertySpecs)
328         return 0;
329
330     optionEntries = g_new0(GOptionEntry, numProperties + 1);
331     numEntries = 0;
332     for (i = 0; i < numProperties; i++) {
333         GParamSpec *param = propertySpecs[i];
334
335         /* Fill in structures only for writable properties. */
336         if (!param || !(param->flags & G_PARAM_WRITABLE))
337             continue;
338
339         GType gParamType = G_PARAM_SPEC_VALUE_TYPE(param);
340         if (gParamType == G_TYPE_BOOLEAN || gParamType == G_TYPE_STRING || gParamType == G_TYPE_INT
341             || gParamType == G_TYPE_FLOAT) {
342             GOptionEntry *optionEntry = &optionEntries[numEntries++];
343             optionEntry->long_name = g_param_spec_get_name(param);
344
345             /* There is no easy way to figure our short name for generated option entries.
346                optionEntry.short_name=*/
347             /* For bool arguments "enable" type make option argument not required. */
348             if (gParamType == G_TYPE_BOOLEAN && (strstr(optionEntry->long_name, "enable")))
349                 optionEntry->flags = G_OPTION_FLAG_OPTIONAL_ARG;
350             optionEntry->arg = G_OPTION_ARG_CALLBACK;
351             optionEntry->arg_data = parseOptionEntryCallback;
352             optionEntry->description = g_param_spec_get_blurb(param);
353             optionEntry->arg_description = g_type_name(gParamType);
354         }
355     }
356     g_free(propertySpecs);
357
358     return optionEntries;
359 }
360
361 static gboolean addWebSettingsGroupToContext(GOptionContext *context, WebKitWebSettings* webkitSettings)
362 {
363     GOptionEntry *optionEntries = getOptionEntriesFromWebKitWebSettings(webkitSettings);
364     if (!optionEntries)
365         return FALSE;
366
367     GOptionGroup *webSettingsGroup = g_option_group_new("websettings",
368                                                         "WebKitWebSettings writable properties for default WebKitWebView",
369                                                         "WebKitWebSettings properties",
370                                                         webkitSettings,
371                                                         NULL);
372     g_option_group_add_entries(webSettingsGroup, optionEntries);
373     g_free(optionEntries);
374
375     /* Option context takes ownership of the group. */
376     g_option_context_add_group(context, webSettingsGroup);
377
378     return TRUE;
379 }
380 #endif
381
382 int main(int argc, char* argv[])
383 {
384 #ifndef WEBKIT2
385     WebKitWebSettings *webkitSettings = 0;
386 #endif
387     const gchar **uriArguments = 0;
388     const GOptionEntry commandLineOptions[] =
389     {
390         { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL]" },
391         { 0, 0, 0, 0, 0, 0, 0 }
392     };
393
394     gtk_init(&argc, &argv);
395     if (!g_thread_supported())
396         g_thread_init(NULL);
397
398     GOptionContext *context = g_option_context_new(0);
399     g_option_context_add_main_entries(context, commandLineOptions, 0);
400     g_option_context_add_group(context, gtk_get_option_group(TRUE));
401 #ifndef WEBKIT2
402     webkitSettings = webkit_web_settings_new();
403     if (!addWebSettingsGroupToContext(context, webkitSettings)) {
404         g_object_unref(webkitSettings);
405         webkitSettings = 0;
406     }
407 #endif
408
409     GError *error = 0;
410     if (!g_option_context_parse(context, &argc, &argv, &error)) {
411         g_printerr("Cannot parse arguments: %s\n", error->message);
412         g_error_free(error);
413         g_option_context_free(context);
414
415         return 1;
416     }
417     g_option_context_free(context);
418
419 #ifndef WEBKIT2
420 #ifdef SOUP_TYPE_PROXY_RESOLVER_DEFAULT
421     soup_session_add_feature_by_type(webkit_get_default_session(), SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
422 #else
423     const char *httpProxy = g_getenv("http_proxy");
424     if (httpProxy) {
425         SoupURI *proxyUri = soup_uri_new(httpProxy);
426         g_object_set(webkit_get_default_session(), SOUP_SESSION_PROXY_URI, proxyUri, NULL);
427         soup_uri_free(proxyUri);
428     }
429 #endif
430 #endif
431
432     WebKitWebView *webView;
433     GtkWidget *main_window = createWindow(&webView);
434
435 #ifndef WEBKIT2
436     if (webkitSettings) {
437         webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
438         g_object_unref(webkitSettings);
439     }
440 #endif
441
442     const gchar *uri = (uriArguments ? uriArguments[0] : "http://www.google.com/");
443     gchar *fileURL = filenameToURL(uri);
444
445     webkit_web_view_load_uri(webView, fileURL ? fileURL : uri);
446     g_free(fileURL);
447
448     gtk_widget_grab_focus(GTK_WIDGET(webView));
449     gtk_widget_show_all(main_window);
450     gtk_main();
451
452     return 0;
453 }