static void
test_input (const gchar* input,
const gchar* expected)
{
static KatzeArray* search_engines = NULL;
if (G_UNLIKELY (!search_engines))
{
KatzeItem* item;
search_engines = katze_array_new (KATZE_TYPE_ITEM);
item = g_object_new (KATZE_TYPE_ITEM,
"uri", SM "%s",
"token", "sm", NULL);
katze_array_add_item (search_engines, item);
g_object_unref (item);
item = g_object_new (KATZE_TYPE_ITEM,
"uri", SM,
"token", "se", NULL);
katze_array_add_item (search_engines, item);
g_object_unref (item);
}
gchar* uri = sokoke_magic_uri (input, search_engines);
if (g_strcmp0 (uri, expected))
{
g_error ("Input: %s\nExpected: %s\nResult: %s",
input ? input : "NULL",
expected ? expected : "NULL",
uri ? uri : "NULL");
}
g_free (uri);
}
KatzeArray* midorator_history_get_command_history(MidoriApp* app) {
KatzeArray *ret = g_object_get_data(G_OBJECT(app), "midorator_command_history");
if (ret)
return ret;
KatzeArray *br_history = midorator_history_get_browser_history(app);
sqlite3 *db = g_object_get_data(G_OBJECT(br_history), "db");
if (!db)
return NULL;
if (sqlite3_exec(db, "CREATE TABLE IF NOT EXISTS midorator_command_history (id integer, command text);", NULL, NULL, NULL) != SQLITE_OK)
return NULL;
ret = katze_array_new(G_TYPE_STRING);
midorator_history_fill(ret, db, "midorator_command_history", "command");
g_signal_connect (ret, "add-item", G_CALLBACK (midorator_history_add_item_cb), db);
g_signal_connect (ret, "remove-item", G_CALLBACK (midorator_history_remove_item_cb), db);
g_signal_connect (ret, "move-item", G_CALLBACK (midorator_history_move_item_cb), db);
g_signal_connect (ret, "clear", G_CALLBACK (midorator_history_clear_cb), db);
g_object_set_data(G_OBJECT(app), "midorator_command_history", ret);
return ret;
}
KatzeArray* midorator_history_get_bookmarks(MidoriApp* app) {
KatzeArray *bookmarks = NULL;
KatzeArray *ret = katze_array_new(KATZE_TYPE_ITEM);
g_object_get(app, "bookmarks", &bookmarks, NULL);
sqlite3 *db = g_object_get_data(bookmarks, "db");
if (!db)
return g_object_ref(bookmarks);
sqlite3_stmt* stmt;
sqlite3_prepare_v2(db, "SELECT title, uri, desc FROM bookmarks;", -1, &stmt, NULL);
while (sqlite3_step(stmt) == SQLITE_ROW) {
const char *title = sqlite3_column_text(stmt, 0);
const char *uri = sqlite3_column_text(stmt, 1);
const char *desc = sqlite3_column_text(stmt, 2);
KatzeItem *it = katze_item_new();
katze_item_set_uri(it, uri);
katze_item_set_text(it, desc);
katze_item_set_name(it, title);
katze_array_add_item(ret, it);
g_object_unref(it);
}
sqlite3_finalize(stmt);
return ret;
}
MidoriApp*
midori_normal_app_new (const gchar* config,
gchar* nickname,
gboolean diagnostic_dialog,
gchar** open_uris,
gchar** execute_commands,
gint inactivity_reset,
const gchar* block_uris)
{
if (g_str_has_suffix (nickname, "portable"))
midori_paths_init (MIDORI_RUNTIME_MODE_PORTABLE, config);
else if (g_str_has_suffix (nickname, "normal"))
midori_paths_init (MIDORI_RUNTIME_MODE_NORMAL, config);
else
g_assert_not_reached ();
MidoriApp* app = midori_app_new (nickname);
if (midori_app_instance_is_running (app))
{
/* midori_debug makes no sense on a running instance */
if (g_getenv ("MIDORI_DEBUG"))
g_warning ("MIDORI_DEBUG only works for a new instance");
/* It makes no sense to show a crash dialog while running */
if (!diagnostic_dialog)
{
if (execute_commands != NULL)
midori_app_send_command (app, execute_commands);
if (open_uris != NULL)
midori_app_instance_send_uris (app, open_uris);
if (!execute_commands && !open_uris)
midori_app_instance_send_new_browser (app);
if (g_application_get_is_registered (G_APPLICATION (app)))
return NULL;
}
/* FIXME: We mustn't lose the URL here; either instance is freezing or inside a crash dialog */
sokoke_message_dialog (GTK_MESSAGE_INFO,
_("An instance of Midori is already running but not responding.\n"),
open_uris ? *open_uris : "", TRUE);
return (void*)0xdeadbeef;
}
GString* error_messages = g_string_new (NULL);
GError* error = NULL;
gchar** extensions;
MidoriWebSettings* settings = midori_settings_new_full (&extensions);
g_object_set (settings,
"enable-developer-extras", TRUE,
"enable-html5-database", TRUE,
"block-uris", block_uris,
NULL);
if (inactivity_reset > 0)
g_object_set (settings, "inactivity-reset", inactivity_reset, NULL);
KatzeArray* search_engines = midori_search_engines_new_from_folder (error_messages);
/* Pick first search engine as default if not set */
gchar* uri = katze_object_get_string (settings, "location-entry-search");
if (!(uri && *uri) && !katze_array_is_empty (search_engines))
{
KatzeItem* item = katze_array_get_nth_item (search_engines, 0);
g_object_set (settings, "location-entry-search",
katze_item_get_uri (item), NULL);
}
g_free (uri);
MidoriBookmarksDb* bookmarks;
gchar* errmsg = NULL;
if (!(bookmarks = midori_bookmarks_db_new (&errmsg)))
{
g_string_append_printf (error_messages,
_("Bookmarks couldn't be loaded: %s\n"), errmsg);
katze_assign (errmsg, NULL);
}
gchar* config_file = NULL;
KatzeArray* session = katze_array_new (KATZE_TYPE_ITEM);
MidoriStartup load_on_startup = katze_object_get_enum (settings, "load-on-startup");
if (load_on_startup >= MIDORI_STARTUP_LAST_OPEN_PAGES)
{
katze_assign (config_file, midori_paths_get_config_filename_for_reading ("session.xbel"));
error = NULL;
if (!midori_array_from_file (session, config_file, "xbel-tiny", &error))
{
if (error->code != G_FILE_ERROR_NOENT)
g_string_append_printf (error_messages,
_("The session couldn't be loaded: %s\n"), error->message);
g_error_free (error);
}
}
KatzeArray* trash = katze_array_new (KATZE_TYPE_ITEM);
g_signal_connect_after (trash, "add-item",
G_CALLBACK (midori_trash_add_item_cb), NULL);
g_signal_connect_after (trash, "remove-item",
G_CALLBACK (midori_trash_remove_item_cb), NULL);
katze_assign (config_file, g_build_filename (config, "tabtrash.xbel", NULL));
error = NULL;
if (!midori_array_from_file (trash, config_file, "xbel-tiny", &error))
{
if (error->code != G_FILE_ERROR_NOENT)
g_string_append_printf (error_messages,
_("The trash couldn't be loaded: %s\n"), error->message);
g_error_free (error);
}
KatzeArray* history;
if (!(history = midori_history_new (&errmsg)))
{
g_string_append_printf (error_messages,
_("The history couldn't be loaded: %s\n"), errmsg);
katze_assign (errmsg, NULL);
}
//add by zgh 20150206
KatzeArray* download;
if (!(download = midori_download_db_new (&errmsg)))
{
g_string_append_printf (error_messages,
_("The download couldn't be loaded: %s\n"), errmsg);
katze_assign (errmsg, NULL);
}
katze_assign (config_file, midori_paths_get_config_filename_for_reading ("speeddial"));
MidoriSpeedDial* dial = midori_speed_dial_new (config_file, NULL);
if (error_messages->len)
{
GtkWidget* dialog = gtk_message_dialog_new (
NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_NONE,
_("The following errors occured:"));
gtk_message_dialog_format_secondary_text (
GTK_MESSAGE_DIALOG (dialog), "%s", error_messages->str);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("_Ignore"), GTK_RESPONSE_ACCEPT,
NULL);
if (midori_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT)
return (void*)0xdeadbeef;
gtk_widget_destroy (dialog);
}
g_string_free (error_messages, TRUE);
g_object_set_data (G_OBJECT (app), "execute-commands", execute_commands);
g_object_set_data (G_OBJECT (app), "open-uris", open_uris);
g_object_set_data_full (G_OBJECT (app), "extensions", extensions, (GDestroyNotify)g_strfreev);
katze_item_set_parent (KATZE_ITEM (session), app);
katze_assign (config_file, midori_paths_get_config_filename_for_reading ("search"));
midori_search_engines_set_filename (search_engines, config_file);
if ((midori_app_get_crashed (app)
&& katze_object_get_boolean (settings, "show-crash-dialog")
&& open_uris && !execute_commands)
|| diagnostic_dialog)
{
gint response = midori_frontend_diagnostic_dialog (app, settings, session);
if (response == G_MAXINT)
return NULL;
load_on_startup = response;
}
katze_item_set_parent (KATZE_ITEM (session), NULL);
g_object_unref (session);
g_object_set_data (G_OBJECT (settings), "load-on-startup", GINT_TO_POINTER (load_on_startup));
g_object_set (app, "settings", settings,
"bookmarks", bookmarks,
"trash", trash,
"search-engines", search_engines,
"history", history,
"download", download,
"speed-dial", dial,
NULL);
g_signal_connect (app, "add-browser",
G_CALLBACK (midori_app_add_browser_cb), NULL);
midori_session_persistent_settings (settings, app);
g_idle_add (midori_load_soup_session_full, settings);
g_idle_add (midori_load_extensions, app);
return app;
}
MidoriBrowser*
midori_private_app_new (const gchar* config,
const gchar* webapp,
gchar** open_uris,
gchar** execute_commands,
gint inactivity_reset,
const gchar* block_uris)
{
guint i;
midori_paths_init (MIDORI_RUNTIME_MODE_PRIVATE, config);
#ifndef HAVE_WEBKIT2
g_object_set_data (G_OBJECT (webkit_get_default_session ()), "pass-through-console", (void*)1);
#endif
/* Mask the timezone, which can be read by Javascript */
g_setenv ("TZ", "UTC", TRUE);
MidoriBrowser* browser = midori_browser_new ();
g_signal_connect (browser, "new-window",
G_CALLBACK (midori_frontend_browser_new_window_cb), NULL);
MidoriWebSettings* settings = midori_settings_new_full (NULL);
g_object_set (settings,
"preferred-languages", "en",
"enable-private-browsing", TRUE,
#ifdef HAVE_LIBSOUP_2_29_91
"first-party-cookies-only", TRUE,
#endif
"enable-html5-database", FALSE,
"enable-html5-local-storage", FALSE,
"enable-offline-web-application-cache", FALSE,
/* Arguably DNS prefetching is or isn't a privacy concern. For the
* lack of more fine-grained control we'll go the safe route. */
"enable-dns-prefetching", FALSE,
"strip-referer", TRUE,
"show-panel", FALSE,
"last-window-state", MIDORI_WINDOW_NORMAL,
"inactivity-reset", inactivity_reset,
"block-uris", block_uris,
NULL);
midori_load_soup_session (settings);
/* In-memory trash for re-opening closed tabs */
KatzeArray* trash = katze_array_new (KATZE_TYPE_ITEM);
g_signal_connect_after (trash, "add-item",
G_CALLBACK (midori_trash_add_item_no_save_cb), NULL);
KatzeArray* search_engines = midori_search_engines_new_from_folder (NULL);
g_object_set (browser,
"settings", settings,
"trash", trash,
"search-engines", search_engines,
NULL);
g_object_unref (settings);
g_object_unref (trash);
g_object_unref (search_engines);
midori_browser_set_action_visible (browser, "Tools", FALSE);
midori_browser_set_action_visible (browser, "ClearPrivateData", FALSE);
#if ENABLE_ADDSPEEDDIAL
midori_browser_set_action_visible (browser, "AddSpeedDial", FALSE);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
g_object_set (gtk_widget_get_settings (GTK_WIDGET (browser)),
"gtk-application-prefer-dark-theme", TRUE,
NULL);
#endif
if (webapp != NULL)
{
gchar* tmp_uri = sokoke_magic_uri (webapp, FALSE, TRUE);
g_object_set (settings, "homepage", tmp_uri, NULL);
midori_browser_add_uri (browser, tmp_uri);
g_free (tmp_uri);
}
for (i = 0; open_uris && open_uris[i]; i++)
{
gchar* new_uri = sokoke_magic_uri (open_uris[i], FALSE, TRUE);
midori_browser_add_uri (browser, new_uri);
g_free (new_uri);
}
if (midori_browser_get_n_pages (browser) == 0)
midori_browser_add_uri (browser, "about:private");
gtk_widget_show (GTK_WIDGET (browser));
for (i = 0; execute_commands && execute_commands[i]; i++)
{
midori_browser_assert_action (browser, execute_commands[i]);
midori_browser_activate_action (browser, execute_commands[i]);
}
/* FIXME need proper stock extension mechanism */
//由于整合了若干预置扩展，此处相应修改
#if 0
midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true");
midori_browser_activate_action (browser, "libabout." G_MODULE_SUFFIX "=true");
midori_browser_activate_action (browser, "libopen-with." G_MODULE_SUFFIX "=true");
#else
midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true");
midori_browser_activate_action (browser, "libbuiltinextension." G_MODULE_SUFFIX "=true");
#endif
g_assert (g_module_error () == NULL);
return browser;
}
