Tools/MiniBrowser/gtk/main.c

   1 /*
   2  * Copyright (C) 2006, 2007 Apple Inc.
   3  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
   4  * Copyright (C) 2011 Igalia S.L.
   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 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 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 "cmakeconfig.h"
  29
  30 #include "BrowserWindow.h"
  31 #include <errno.h>
  32 #include <gtk/gtk.h>
  33 #include <string.h>
  34 #include <webkit2/webkit2.h>
  35
  36 #define MINI_BROWSER_ERROR (miniBrowserErrorQuark())
  37
  38 static const gchar **uriArguments = NULL;
  39 static const char *miniBrowserAboutScheme = "minibrowser-about";
  40 static GdkRGBA *backgroundColor;
  41 static gboolean editorMode;
  42 static const char *sessionFile;
  43 static char *geometry;
  44
  45 typedef enum {
  46     MINI_BROWSER_ERROR_INVALID_ABOUT_PATH
  47 } MiniBrowserError;
  48
  49 static GQuark miniBrowserErrorQuark()
  50 {
  51     return g_quark_from_string("minibrowser-quark");
  52 }
  53
  54 static gchar *argumentToURL(const char *filename)
  55 {
  56     GFile *gfile = g_file_new_for_commandline_arg(filename);
  57     gchar *fileURL = g_file_get_uri(gfile);
  58     g_object_unref(gfile);
  59
  60     return fileURL;
  61 }
  62
  63 static void createBrowserWindow(const gchar *uri, WebKitSettings *webkitSettings, gboolean shouldLoadSession)
  64 {
  65     GtkWidget *webView = webkit_web_view_new();
  66     if (editorMode)
  67         webkit_web_view_set_editable(WEBKIT_WEB_VIEW(webView), TRUE);
  68     GtkWidget *mainWindow = browser_window_new(WEBKIT_WEB_VIEW(webView), NULL);
  69     if (backgroundColor)
  70         browser_window_set_background_color(BROWSER_WINDOW(mainWindow), backgroundColor);
  71     if (geometry)
  72         gtk_window_parse_geometry(GTK_WINDOW(mainWindow), geometry);
  73
  74     if (webkitSettings)
  75         webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webView), webkitSettings);
  76
  77     if (!editorMode) {
  78         if (shouldLoadSession && sessionFile)
  79             browser_window_load_session(BROWSER_WINDOW(mainWindow), sessionFile);
  80         else {
  81             gchar *url = argumentToURL(uri);
  82             browser_window_load_uri(BROWSER_WINDOW(mainWindow), url);
  83             g_free(url);
  84         }
  85     }
  86
  87     gtk_widget_grab_focus(webView);
  88     gtk_widget_show(mainWindow);
  89 }
  90
  91 static gboolean parseBackgroundColor(const char *optionName, const char *value, gpointer data, GError **error)
  92 {
  93     GdkRGBA rgba;
  94     if (gdk_rgba_parse(&rgba, value)) {
  95         backgroundColor = gdk_rgba_copy(&rgba);
  96         return TRUE;
  97     }
  98
  99     g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Failed to parse '%s' as RGBA color", value);
 100     return FALSE;
 101 }
 102
 103 static const GOptionEntry commandLineOptions[] =
 104 {
 105     { "bg-color", 0, 0, G_OPTION_ARG_CALLBACK, parseBackgroundColor, "Background color", NULL },
 106     { "editor-mode", 'e', 0, G_OPTION_ARG_NONE, &editorMode, "Run in editor mode", NULL },
 107     { "session-file", 's', 0, G_OPTION_ARG_FILENAME, &sessionFile, "Session file", "FILE" },
 108     { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry, "Set the size and position of the window (WIDTHxHEIGHT+X+Y)", "GEOMETRY" },
 109     { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL…]" },
 110     { 0, 0, 0, 0, 0, 0, 0 }
 111 };
 112
 113 static gboolean parseOptionEntryCallback(const gchar *optionNameFull, const gchar *value, WebKitSettings *webSettings, GError **error)
 114 {
 115     if (strlen(optionNameFull) <= 2) {
 116         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Invalid option %s", optionNameFull);
 117         return FALSE;
 118     }
 119
 120     /* We have two -- in option name so remove them. */
 121     const gchar *optionName = optionNameFull + 2;
 122     GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(webSettings), optionName);
 123     if (!spec) {
 124         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Cannot find web settings for option %s", optionNameFull);
 125         return FALSE;
 126     }
 127
 128     switch (G_PARAM_SPEC_VALUE_TYPE(spec)) {
 129     case G_TYPE_BOOLEAN: {
 130         gboolean propertyValue = !(value && g_ascii_strcasecmp(value, "true") && strcmp(value, "1"));
 131         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
 132         break;
 133     }
 134     case G_TYPE_STRING:
 135         g_object_set(G_OBJECT(webSettings), optionName, value, NULL);
 136         break;
 137     case G_TYPE_INT: {
 138         glong propertyValue;
 139         gchar *end;
 140
 141         errno = 0;
 142         propertyValue = g_ascii_strtoll(value, &end, 0);
 143         if (errno == ERANGE || propertyValue > G_MAXINT || propertyValue < G_MININT) {
 144             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Integer value '%s' for %s out of range", value, optionNameFull);
 145             return FALSE;
 146         }
 147         if (errno || value == end) {
 148             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse integer value '%s' for %s", value, optionNameFull);
 149             return FALSE;
 150         }
 151         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
 152         break;
 153     }
 154     case G_TYPE_FLOAT: {
 155         gdouble propertyValue;
 156         gchar *end;
 157
 158         errno = 0;
 159         propertyValue = g_ascii_strtod(value, &end);
 160         if (errno == ERANGE || propertyValue > G_MAXFLOAT || propertyValue < G_MINFLOAT) {
 161             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Float value '%s' for %s out of range", value, optionNameFull);
 162             return FALSE;
 163         }
 164         if (errno || value == end) {
 165             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse float value '%s' for %s", value, optionNameFull);
 166             return FALSE;
 167         }
 168         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
 169         break;
 170     }
 171     default:
 172         g_assert_not_reached();
 173     }
 174
 175     return TRUE;
 176 }
 177
 178 static gboolean isValidParameterType(GType gParamType)
 179 {
 180     return (gParamType == G_TYPE_BOOLEAN || gParamType == G_TYPE_STRING || gParamType == G_TYPE_INT
 181             || gParamType == G_TYPE_FLOAT);
 182 }
 183
 184 static GOptionEntry* getOptionEntriesFromWebKitSettings(WebKitSettings *webSettings)
 185 {
 186     GParamSpec **propertySpecs;
 187     GOptionEntry *optionEntries;
 188     guint numProperties, numEntries, i;
 189
 190     propertySpecs = g_object_class_list_properties(G_OBJECT_GET_CLASS(webSettings), &numProperties);
 191     if (!propertySpecs)
 192         return NULL;
 193
 194     optionEntries = g_new0(GOptionEntry, numProperties + 1);
 195     numEntries = 0;
 196     for (i = 0; i < numProperties; i++) {
 197         GParamSpec *param = propertySpecs[i];
 198
 199         /* Fill in structures only for writable and not construct-only properties. */
 200         if (!param || !(param->flags & G_PARAM_WRITABLE) || (param->flags & G_PARAM_CONSTRUCT_ONLY))
 201             continue;
 202
 203         GType gParamType = G_PARAM_SPEC_VALUE_TYPE(param);
 204         if (!isValidParameterType(gParamType))
 205             continue;
 206
 207         GOptionEntry *optionEntry = &optionEntries[numEntries++];
 208         optionEntry->long_name = g_param_spec_get_name(param);
 209
 210         /* There is no easy way to figure our short name for generated option entries.
 211            optionEntry.short_name=*/
 212         /* For bool arguments "enable" type make option argument not required. */
 213         if (gParamType == G_TYPE_BOOLEAN && (strstr(optionEntry->long_name, "enable")))
 214             optionEntry->flags = G_OPTION_FLAG_OPTIONAL_ARG;
 215         optionEntry->arg = G_OPTION_ARG_CALLBACK;
 216         optionEntry->arg_data = parseOptionEntryCallback;
 217         optionEntry->description = g_param_spec_get_blurb(param);
 218         optionEntry->arg_description = g_type_name(gParamType);
 219     }
 220     g_free(propertySpecs);
 221
 222     return optionEntries;
 223 }
 224
 225 static gboolean addSettingsGroupToContext(GOptionContext *context, WebKitSettings* webkitSettings)
 226 {
 227     GOptionEntry *optionEntries = getOptionEntriesFromWebKitSettings(webkitSettings);
 228     if (!optionEntries)
 229         return FALSE;
 230
 231     GOptionGroup *webSettingsGroup = g_option_group_new("websettings",
 232                                                         "WebKitSettings writable properties for default WebKitWebView",
 233                                                         "WebKitSettings properties",
 234                                                         webkitSettings,
 235                                                         NULL);
 236     g_option_group_add_entries(webSettingsGroup, optionEntries);
 237     g_free(optionEntries);
 238
 239     /* Option context takes ownership of the group. */
 240     g_option_context_add_group(context, webSettingsGroup);
 241
 242     return TRUE;
 243 }
 244
 245 static void
 246 aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, gpointer userData)
 247 {
 248     GInputStream *stream;
 249     gsize streamLength;
 250     const gchar *path;
 251     gchar *contents;
 252     GError *error;
 253
 254     path = webkit_uri_scheme_request_get_path(request);
 255     if (!g_strcmp0(path, "minibrowser")) {
 256         contents = g_strdup_printf("<html><body><h1>WebKitGTK+ MiniBrowser</h1><p>The WebKit2 test browser of the GTK+ port.</p><p>WebKit version: %d.%d.%d</p></body></html>",
 257             webkit_get_major_version(),
 258             webkit_get_minor_version(),
 259             webkit_get_micro_version());
 260         streamLength = strlen(contents);
 261         stream = g_memory_input_stream_new_from_data(contents, streamLength, g_free);
 262
 263         webkit_uri_scheme_request_finish(request, stream, streamLength, "text/html");
 264         g_object_unref(stream);
 265     } else {
 266         error = g_error_new(MINI_BROWSER_ERROR, MINI_BROWSER_ERROR_INVALID_ABOUT_PATH, "Invalid about:%s page.", path);
 267         webkit_uri_scheme_request_finish_error(request, error);
 268         g_error_free(error);
 269     }
 270 }
 271
 272 int main(int argc, char *argv[])
 273 {
 274     gtk_init(&argc, &argv);
 275 #if ENABLE_DEVELOPER_MODE
 276     g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);
 277 #endif
 278
 279     const gchar *singleprocess = g_getenv("MINIBROWSER_SINGLEPROCESS");
 280     webkit_web_context_set_process_model(webkit_web_context_get_default(), (singleprocess && *singleprocess) ?
 281         WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS : WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES);
 282
 283     GOptionContext *context = g_option_context_new(NULL);
 284     g_option_context_add_main_entries(context, commandLineOptions, 0);
 285     g_option_context_add_group(context, gtk_get_option_group(TRUE));
 286
 287     WebKitSettings *webkitSettings = webkit_settings_new();
 288     webkit_settings_set_enable_developer_extras(webkitSettings, TRUE);
 289     webkit_settings_set_enable_webgl(webkitSettings, TRUE);
 290     if (!addSettingsGroupToContext(context, webkitSettings))
 291         g_clear_object(&webkitSettings);
 292
 293     GError *error = 0;
 294     if (!g_option_context_parse(context, &argc, &argv, &error)) {
 295         g_printerr("Cannot parse arguments: %s\n", error->message);
 296         g_error_free(error);
 297         g_option_context_free(context);
 298
 299         return 1;
 300     }
 301     g_option_context_free (context);
 302
 303     // Enable the favicon database, by specifying the default directory.
 304     webkit_web_context_set_favicon_database_directory(webkit_web_context_get_default(), NULL);
 305
 306     webkit_web_context_register_uri_scheme(webkit_web_context_get_default(), miniBrowserAboutScheme, aboutURISchemeRequestCallback, NULL, NULL);
 307
 308     if (uriArguments) {
 309         int i;
 310
 311         for (i = 0; uriArguments[i]; i++)
 312             createBrowserWindow(uriArguments[i], webkitSettings, FALSE);
 313     } else
 314         createBrowserWindow(BROWSER_DEFAULT_URL, webkitSettings, TRUE);
 315
 316     g_clear_object(&webkitSettings);
 317
 318     gtk_main();
 319
 320     return 0;
 321 }