Пример #1
0
static void
browser_create (void)
{
    MidoriApp* app;
    MidoriBrowser* browser;
    GtkActionGroup* action_group;
    GList* actions;

    app = midori_app_new ();
    browser = midori_app_create_browser (app);
    gtk_widget_destroy (GTK_WIDGET (browser));

    app = midori_app_new ();
    browser = midori_app_create_browser (app);
    action_group = midori_browser_get_action_group (browser);
    actions = gtk_action_group_list_actions (action_group);
    while (actions)
    {
        GtkAction* action = actions->data;
        if (g_strcmp0 (gtk_action_get_name (action), "WindowClose"))
            if (g_strcmp0 (gtk_action_get_name (action), "EncodingCustom"))
                if (g_strcmp0 (gtk_action_get_name (action), "AddSpeedDial"))
                    gtk_action_activate (action);
        actions = g_list_next (actions);
    }
    g_list_free (actions);
    gtk_widget_destroy (GTK_WIDGET (browser));
    g_object_unref (app);
}
Пример #2
0
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;
}