/* * Copyright (C) 2000-2004 Marco Pesenti Gritti * Copyright (C) 2003, 2004 Christian Persch * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * $Id$ */ #include "config.h" #include "ephy-shell.h" #include "ephy-type-builtins.h" #include "ephy-embed-shell.h" #include "ephy-embed-single.h" #include "eel-gconf-extensions.h" #include "ephy-prefs.h" #include "ephy-file-helpers.h" #include "ephy-favicon-cache.h" #include "ephy-window.h" #include "ephy-bookmarks-import.h" #include "ephy-bookmarks-editor.h" #include "ephy-history-window.h" #include "pdm-dialog.h" #include "prefs-dialog.h" #include "ephy-debug.h" #include "ephy-extensions-manager.h" #include "ephy-session.h" #include "ephy-lockdown.h" #include "downloader-view.h" #include "egg-toolbars-model.h" #include "ephy-toolbars-model.h" #include "ephy-toolbar.h" #include "ephy-automation.h" #include "print-dialog.h" #include "ephy-prefs.h" #include "ephy-gui.h" #include "ephy-dbus.h" #include #include #include #include #include #include #include #include #include #include #define AUTOMATION_IID "OAFIID:GNOME_Epiphany_Automation" #define EPHY_SHELL_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_SHELL, EphyShellPrivate)) struct _EphyShellPrivate { BonoboGenericFactory *automation_factory; EphySession *session; GObject *lockdown; EphyBookmarks *bookmarks; EggToolbarsModel *toolbars_model; EggToolbarsModel *fs_toolbars_model; EphyExtensionsManager *extensions_manager; GObject *dbus_service; GtkWidget *bme; GtkWidget *history_window; GObject *pdm_dialog; GObject *prefs_dialog; GObject *print_setup_dialog; GList *del_on_exit; gboolean embed_single_connected; }; EphyShell *ephy_shell = NULL; static void ephy_shell_class_init (EphyShellClass *klass); static void ephy_shell_init (EphyShell *shell); static void ephy_shell_dispose (GObject *object); static void ephy_shell_finalize (GObject *object); static GObject *impl_get_embed_single (EphyEmbedShell *embed_shell); static GObjectClass *parent_class = NULL; GQuark ephy_shell_error_quark (void) { static GQuark q = 0; if (q == 0) { q = g_quark_from_static_string ("ephy-shell-error-quark"); } return q; } GType ephy_shell_get_type (void) { static GType type = 0; if (G_UNLIKELY (type == 0)) { static const GTypeInfo our_info = { sizeof (EphyShellClass), NULL, /* base_init */ NULL, /* base_finalize */ (GClassInitFunc) ephy_shell_class_init, NULL, NULL, /* class_data */ sizeof (EphyShell), 0, /* n_preallocs */ (GInstanceInitFunc) ephy_shell_init }; type = g_type_register_static (EPHY_TYPE_EMBED_SHELL, "EphyShell", &our_info, 0); } return type; } static void ephy_shell_class_init (EphyShellClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); EphyEmbedShellClass *embed_shell_class = EPHY_EMBED_SHELL_CLASS (klass); parent_class = g_type_class_peek_parent (klass); object_class->dispose = ephy_shell_dispose; object_class->finalize = ephy_shell_finalize; embed_shell_class->get_embed_single = impl_get_embed_single; g_type_class_add_private (object_class, sizeof(EphyShellPrivate)); } static EphyEmbed * ephy_shell_new_window_cb (EphyEmbedSingle *single, EphyEmbed *parent_embed, EphyEmbedChrome chromemask, EphyShell *shell) { GtkWidget *parent = NULL; EphyTab *new_tab; gboolean is_popup; EphyNewTabFlags flags = EPHY_NEW_TAB_DONT_SHOW_WINDOW | EPHY_NEW_TAB_APPEND_LAST | EPHY_NEW_TAB_IN_NEW_WINDOW | EPHY_NEW_TAB_JUMP; LOG ("ephy_shell_new_window_cb tab chrome %d", chromemask); if (eel_gconf_get_boolean (CONF_LOCKDOWN_DISABLE_JAVASCRIPT_CHROME)) { chromemask = EPHY_EMBED_CHROME_ALL; } if (parent_embed != NULL) { /* this will either be a EphyWindow, or the embed itself * (in case it's about to be destroyed, which means it's already * removed from its tab) */ parent = gtk_widget_get_toplevel (GTK_WIDGET (parent_embed)); } /* what's a popup ? ATM, any window opened with menubar toggled on * is *not* a popup */ is_popup = (chromemask & EPHY_EMBED_CHROME_MENUBAR) == 0; new_tab = ephy_shell_new_tab_full (shell, EPHY_IS_WINDOW (parent) ? EPHY_WINDOW (parent) : NULL, NULL, NULL, flags, chromemask, is_popup, 0); return ephy_tab_get_embed (new_tab); } static gboolean ephy_shell_add_sidebar_cb (EphyEmbedSingle *embed_single, const char *url, const char *title, EphyShell *shell) { EphySession *session; EphyWindow *window; GtkWidget *dialog; session = EPHY_SESSION (ephy_shell_get_session (shell)); g_return_val_if_fail (EPHY_IS_SESSION (session), FALSE); window = ephy_session_get_active_window (session); dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Sidebar extension required")); gtk_window_set_title (GTK_WINDOW (dialog), _("Sidebar Extension Required")); gtk_window_set_icon_name (GTK_WINDOW (dialog), "web-browser"); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("The link you clicked needs the sidebar extension to be " "installed.")); g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog); gtk_widget_show (dialog); return TRUE; } static GObject* impl_get_embed_single (EphyEmbedShell *embed_shell) { EphyShell *shell = EPHY_SHELL (embed_shell); GObject *embed_single; embed_single = EPHY_EMBED_SHELL_CLASS (parent_class)->get_embed_single (embed_shell); if (embed_single != NULL && shell->priv->embed_single_connected == FALSE) { g_signal_connect_object (embed_single, "new-window", G_CALLBACK (ephy_shell_new_window_cb), shell, G_CONNECT_AFTER); g_signal_connect_object (embed_single, "add-sidebar", G_CALLBACK (ephy_shell_add_sidebar_cb), shell, G_CONNECT_AFTER); shell->priv->embed_single_connected = TRUE; } return embed_single; } static BonoboObject * ephy_automation_factory_cb (BonoboGenericFactory *this_factory, const char *iid, EphyShell *shell) { if (strcmp (iid, AUTOMATION_IID) == 0) { return BONOBO_OBJECT (g_object_new (EPHY_TYPE_AUTOMATION, NULL)); } g_assert_not_reached (); return NULL; } static BonoboGenericFactory * ephy_automation_factory_new (EphyShell *shell) { BonoboGenericFactory *factory; GClosure *factory_closure; factory = g_object_new (bonobo_generic_factory_get_type (), NULL); factory_closure = g_cclosure_new (G_CALLBACK (ephy_automation_factory_cb), shell, NULL); bonobo_generic_factory_construct_noreg (factory, AUTOMATION_FACTORY_IID, factory_closure); return factory; } static void ephy_shell_init (EphyShell *shell) { EphyShell **ptr = &ephy_shell; shell->priv = EPHY_SHELL_GET_PRIVATE (shell); /* globally accessible singleton */ g_assert (ephy_shell == NULL); ephy_shell = shell; g_object_add_weak_pointer (G_OBJECT(ephy_shell), (gpointer *)ptr); /* Instantiate the automation factory */ shell->priv->automation_factory = ephy_automation_factory_new (shell); } static char * path_from_command_line_arg (const char *arg) { char path[PATH_MAX]; if (realpath (arg, path) != NULL) { return g_strdup (path); } else { return g_strdup (arg); } } static void open_urls (GNOME_EphyAutomation automation, guint32 user_time, const char **args, CORBA_Environment *ev, gboolean new_tab, gboolean existing_window, gboolean fullscreen) { int i; if (args == NULL) { /* Homepage or resume */ GNOME_EphyAutomation_loadUrlWithStartupId (automation, "", fullscreen, existing_window, new_tab, user_time, ev); } else { for (i = 0; args[i] != NULL; i++) { char *path; path = path_from_command_line_arg (args[i]); GNOME_EphyAutomation_loadUrlWithStartupId (automation, path, fullscreen, existing_window, new_tab, user_time, ev); g_free (path); } } } static gboolean save_yourself_cb (GnomeClient *client, gint phase, GnomeSaveStyle save_style, gboolean shutdown, GnomeInteractStyle interact_style, gboolean fast, EphyShell *shell) { char *argv[] = { NULL, "--load-session", NULL }; char *discard_argv[] = { "rm", "-f", NULL }; EphySession *session; char *tmp, *save_to; LOG ("save_yourself_cb"); tmp = g_build_filename (ephy_dot_dir (), "session_gnome-XXXXXX", NULL); save_to = ephy_file_tmp_filename (tmp, "xml"); g_free (tmp); session = EPHY_SESSION (ephy_shell_get_session (shell)); argv[0] = g_get_prgname (); argv[2] = save_to; gnome_client_set_restart_command (client, 3, argv); discard_argv[2] = save_to; gnome_client_set_discard_command (client, 3, discard_argv); ephy_session_save (session, save_to); g_free (save_to); return TRUE; } static void die_cb (GnomeClient* client, EphyShell *shell) { EphySession *session; LOG ("die_cb"); session = EPHY_SESSION (ephy_shell_get_session (shell)); ephy_session_close (session); } static void gnome_session_init (EphyShell *shell) { GnomeClient *client; client = gnome_master_client (); g_signal_connect_object (client, "save_yourself", G_CALLBACK (save_yourself_cb), shell, 0); /* don't use connect_object here, since that will ref the shell * while dispatching the callbacks! */ g_signal_connect (client, "die", G_CALLBACK (die_cb), shell); } gboolean ephy_shell_startup (EphyShell *shell, EphyShellStartupFlags flags, guint32 user_time, const char **args, const char *string_arg, GError **error) { CORBA_Environment ev; GNOME_EphyAutomation automation; Bonobo_RegistrationResult result; ephy_ensure_dir_exists (ephy_dot_dir ()); CORBA_exception_init (&ev); result = bonobo_activation_register_active_server (AUTOMATION_FACTORY_IID, BONOBO_OBJREF (shell->priv->automation_factory), NULL); switch (result) { case Bonobo_ACTIVATION_REG_SUCCESS: break; case Bonobo_ACTIVATION_REG_ALREADY_ACTIVE: break; case Bonobo_ACTIVATION_REG_NOT_LISTED: g_set_error (error, EPHY_SHELL_ERROR, EPHY_SHELL_ERROR_MISSING_SERVER, _("Bonobo couldn't locate the GNOME_Epiphany_Automation.server " "file. You can use bonobo-activation-sysconf to configure " "the search path for bonobo server files.")); break; case Bonobo_ACTIVATION_REG_ERROR: g_set_error (error, EPHY_SHELL_ERROR, EPHY_SHELL_ERROR_FACTORY_REG_FAILED, _("Epiphany can't be used now, due to an unexpected error " "from Bonobo when attempting to register the automation " "server")); break; default: g_assert_not_reached (); } if (result == Bonobo_ACTIVATION_REG_SUCCESS || result == Bonobo_ACTIVATION_REG_ALREADY_ACTIVE) { automation = bonobo_activation_activate_from_id (AUTOMATION_IID, 0, NULL, &ev); if (CORBA_Object_is_nil (automation, &ev)) { g_set_error (error, EPHY_SHELL_ERROR, EPHY_SHELL_ERROR_OBJECT_REG_FAILED, _("Epiphany can't be used now, due to an unexpected error " "from Bonobo when attempting to locate the automation " "object.")); automation = NULL; goto done; } /* init the session manager up here so we can quit while the resume dialogue is on */ gnome_session_init (shell); if (flags & EPHY_SHELL_STARTUP_BOOKMARKS_EDITOR) { GNOME_EphyAutomation_openBookmarksEditorWithStartupId (automation, user_time, &ev); } else if (flags & EPHY_SHELL_STARTUP_SESSION) { GNOME_EphyAutomation_loadSessionWithStartupId (automation, string_arg, user_time, &ev); } else if (flags & EPHY_SHELL_STARTUP_IMPORT_BOOKMARKS) { GNOME_EphyAutomation_importBookmarks (automation, string_arg, &ev); } else if (flags & EPHY_SHELL_STARTUP_ADD_BOOKMARK) { GNOME_EphyAutomation_addBookmark (automation, string_arg, &ev); } else { open_urls (automation, user_time, args, &ev, flags & EPHY_SHELL_STARTUP_TABS, flags & EPHY_SHELL_STARTUP_EXISTING_WINDOW, flags & EPHY_SHELL_STARTUP_FULLSCREEN); } bonobo_object_release_unref (automation, &ev); } done: CORBA_exception_free (&ev); gdk_notify_startup_complete (); return !(result == Bonobo_ACTIVATION_REG_ALREADY_ACTIVE); } static void ephy_shell_dispose (GObject *object) { EphyShell *shell = EPHY_SHELL (object); EphyShellPrivate *priv = shell->priv; LOG ("EphyShell disposing"); if (priv->automation_factory != NULL) { LOG ("Deregistering bonobo server"); bonobo_activation_unregister_active_server (AUTOMATION_FACTORY_IID, BONOBO_OBJREF (priv->automation_factory)); bonobo_object_unref (priv->automation_factory); priv->automation_factory = NULL; } if (shell->priv->extensions_manager != NULL) { LOG ("Unref extension manager"); /* this will unload the extensions */ g_object_unref (priv->extensions_manager); priv->extensions_manager = NULL; } if (priv->dbus_service != NULL) { LOG ("Shutting down DBUS service"); g_object_unref (priv->dbus_service); priv->dbus_service = NULL; } if (priv->session != NULL) { LOG ("Unref session manager"); g_object_unref (priv->session); priv->session = NULL; } if (priv->lockdown != NULL) { LOG ("Unref lockdown controller"); g_object_unref (priv->lockdown); priv->lockdown = NULL; } if (priv->toolbars_model != NULL) { LOG ("Unref toolbars model"); g_object_unref (priv->toolbars_model); priv->toolbars_model = NULL; } if (priv->fs_toolbars_model != NULL) { LOG ("Unref fullscreen toolbars model"); g_object_unref (priv->fs_toolbars_model); priv->fs_toolbars_model = NULL; } if (priv->bme != NULL) { LOG ("Unref Bookmarks Editor"); gtk_widget_destroy (GTK_WIDGET (priv->bme)); priv->bme = NULL; } if (priv->history_window != NULL) { LOG ("Unref History Window"); gtk_widget_destroy (GTK_WIDGET (priv->history_window)); priv->history_window = NULL; } if (priv->pdm_dialog != NULL) { LOG ("Unref PDM Dialog"); g_object_unref (priv->pdm_dialog); priv->pdm_dialog = NULL; } if (priv->prefs_dialog != NULL) { LOG ("Unref prefs dialog"); g_object_unref (priv->prefs_dialog); priv->prefs_dialog = NULL; } if (priv->print_setup_dialog != NULL) { LOG ("Unref print setup dialog"); g_object_unref (priv->print_setup_dialog); priv->print_setup_dialog = NULL; } if (priv->bookmarks != NULL) { LOG ("Unref bookmarks"); g_object_unref (priv->bookmarks); priv->bookmarks = NULL; } G_OBJECT_CLASS (parent_class)->dispose (object); } static void ephy_shell_finalize (GObject *object) { G_OBJECT_CLASS (parent_class)->finalize (object); LOG ("Ephy shell finalised"); } /** * ephy_shell_get_default: * * Retrieve the default #EphyShell object * * ReturnValue: the default #EphyShell **/ EphyShell * ephy_shell_get_default (void) { return ephy_shell; } EphyShell * ephy_shell_new (void) { return EPHY_SHELL (g_object_new (EPHY_TYPE_SHELL, NULL)); } static gboolean url_is_empty (const char *location) { gboolean is_empty = FALSE; if (location == NULL || location[0] == '\0' || strcmp (location, "about:blank") == 0) { is_empty = TRUE; } return is_empty; } static gboolean load_homepage (EphyEmbed *embed) { char *home; gboolean is_empty; home = eel_gconf_get_string(CONF_GENERAL_HOMEPAGE); if (home == NULL || home[0] == '\0') { g_free (home); home = g_strdup ("about:blank"); } is_empty = url_is_empty (home); ephy_embed_load_url (embed, home); g_free (home); return is_empty; } /** * ephy_shell_new_tab_full: * @shell: a #EphyShell * @parent_window: the target #EphyWindow or %NULL * @previous_tab: the referrer tab or %NULL * @url: an url to load or %NULL * @chrome: a #EphyEmbedChrome mask to use if creating a new window * @is_popup: whether the new window is a popup * @user_time: a timestamp, or 0 * * Create a new tab and the parent window when necessary. * Use this function to open urls in new window/tabs. * * ReturnValue: the created #EphyTab **/ EphyTab * ephy_shell_new_tab_full (EphyShell *shell, EphyWindow *parent_window, EphyTab *previous_tab, const char *url, EphyNewTabFlags flags, EphyEmbedChrome chrome, gboolean is_popup, guint32 user_time) { EphyWindow *window; EphyTab *tab; EphyEmbed *embed; gboolean in_new_window = TRUE; gboolean jump_to; EphyEmbed *previous_embed = NULL; GtkWidget *nb; int position = -1; gboolean is_empty = FALSE; EphyToolbar *toolbar; if (flags & EPHY_NEW_TAB_IN_NEW_WINDOW) in_new_window = TRUE; if (flags & EPHY_NEW_TAB_IN_EXISTING_WINDOW) in_new_window = FALSE; in_new_window = in_new_window && !eel_gconf_get_boolean (CONF_LOCKDOWN_FULLSCREEN); g_return_val_if_fail (in_new_window || !is_popup, NULL); jump_to = (flags & EPHY_NEW_TAB_JUMP) != 0; LOG ("Opening new tab parent-window %p parent-tab %p in-new-window:%s jump-to:%s", parent_window, previous_tab, in_new_window ? "t" : "f", jump_to ? "t" : "f"); if (!in_new_window && parent_window != NULL) { window = parent_window; } else { window = ephy_window_new_with_chrome (chrome, is_popup); } toolbar = EPHY_TOOLBAR (ephy_window_get_toolbar (window)); if (previous_tab != NULL) { previous_embed = ephy_tab_get_embed (previous_tab); } if ((flags & EPHY_NEW_TAB_APPEND_AFTER) && previous_tab != NULL) { nb = ephy_window_get_notebook (window); position = gtk_notebook_page_num (GTK_NOTEBOOK (nb), GTK_WIDGET (previous_tab)) + 1; } tab = ephy_tab_new (); gtk_widget_show (GTK_WIDGET (tab)); embed = ephy_tab_get_embed (tab); ephy_window_add_tab (window, tab, position, jump_to); ephy_gui_window_update_user_time (GTK_WIDGET (window), user_time); if ((flags & EPHY_NEW_TAB_DONT_SHOW_WINDOW) == 0) { gtk_widget_show (GTK_WIDGET (window)); } if (flags & EPHY_NEW_TAB_FULLSCREEN_MODE) { gtk_window_fullscreen (GTK_WINDOW (window)); } if (flags & EPHY_NEW_TAB_HOME_PAGE || flags & EPHY_NEW_TAB_NEW_PAGE) { ephy_tab_set_typed_address (tab, "", EPHY_TAB_ADDRESS_EXPIRE_NEXT); ephy_toolbar_activate_location (toolbar); is_empty = load_homepage (embed); } else if (flags & EPHY_NEW_TAB_OPEN_PAGE) { g_assert (url != NULL); ephy_embed_load_url (embed, url); is_empty = url_is_empty (url); } /* Make sure the initial focus is somewhere sensible and not, for * example, on the reload button. */ if (in_new_window || jump_to) { /* If the location entry is blank, focus that, except if the * page was a copy */ if (is_empty) { /* empty page, focus location entry */ toolbar = EPHY_TOOLBAR (ephy_window_get_toolbar (window)); ephy_toolbar_activate_location (toolbar); } else if (embed != NULL) { /* non-empty page, focus the page. but make sure the widget is realised first! */ gtk_widget_realize (GTK_WIDGET (embed)); gtk_widget_grab_focus (GTK_WIDGET (embed)); } } return tab; } /** * ephy_shell_new_tab: * @shell: a #EphyShell * @parent_window: the target #EphyWindow or %NULL * @previous_tab: the referrer tab or %NULL * @url: an url to load or %NULL * * Create a new tab and the parent window when necessary. * Use this function to open urls in new window/tabs. * * ReturnValue: the created #EphyTab **/ EphyTab * ephy_shell_new_tab (EphyShell *shell, EphyWindow *parent_window, EphyTab *previous_tab, const char *url, EphyNewTabFlags flags) { return ephy_shell_new_tab_full (shell, parent_window, previous_tab, url, flags, EPHY_EMBED_CHROME_ALL, FALSE, 0); } /** * ephy_shell_get_session: * @shell: the #EphyShell * * Returns current session. * * Return value: the current session. **/ GObject * ephy_shell_get_session (EphyShell *shell) { g_return_val_if_fail (EPHY_IS_SHELL (shell), NULL); if (shell->priv->session == NULL) { EphyExtensionsManager *manager; shell->priv->session = g_object_new (EPHY_TYPE_SESSION, NULL); manager = EPHY_EXTENSIONS_MANAGER (ephy_shell_get_extensions_manager (shell)); ephy_extensions_manager_register (manager, G_OBJECT (shell->priv->session)); } return G_OBJECT (shell->priv->session); } /** * ephy_shell_get_lockdown: * @shell: the #EphyShell * * Returns the lockdown controller. * * Return value: the lockdown controller **/ static GObject * ephy_shell_get_lockdown (EphyShell *shell) { g_return_val_if_fail (EPHY_IS_SHELL (shell), NULL); if (shell->priv->lockdown == NULL) { EphyExtensionsManager *manager; shell->priv->lockdown = g_object_new (EPHY_TYPE_LOCKDOWN, NULL); manager = EPHY_EXTENSIONS_MANAGER (ephy_shell_get_extensions_manager (shell)); ephy_extensions_manager_register (manager, G_OBJECT (shell->priv->lockdown)); } return G_OBJECT (shell->priv->session); } EphyBookmarks * ephy_shell_get_bookmarks (EphyShell *shell) { if (shell->priv->bookmarks == NULL) { shell->priv->bookmarks = ephy_bookmarks_new (); } return shell->priv->bookmarks; } GObject * ephy_shell_get_toolbars_model (EphyShell *shell, gboolean fullscreen) { LOG ("ephy_shell_get_toolbars_model fs=%d", fullscreen); if (fullscreen) { if (shell->priv->fs_toolbars_model == NULL) { gboolean success; const char *xml; shell->priv->fs_toolbars_model = egg_toolbars_model_new (); xml = ephy_file ("epiphany-fs-toolbar.xml"); g_return_val_if_fail (xml != NULL, NULL); success = egg_toolbars_model_load (shell->priv->fs_toolbars_model, xml); g_return_val_if_fail (success, NULL); } return G_OBJECT (shell->priv->fs_toolbars_model); } else { if (shell->priv->toolbars_model == NULL) { EphyBookmarks *bookmarks; GObject *bookmarksbar_model; shell->priv->toolbars_model = ephy_toolbars_model_new (); /* get the bookmarks toolbars model. we have to do this * before loading the toolbars model from disk, since * this will connect the get_item_* signals */ bookmarks = ephy_shell_get_bookmarks (shell); bookmarksbar_model = ephy_bookmarks_get_toolbars_model (bookmarks); /* ok, now we can load the model */ ephy_toolbars_model_load (EPHY_TOOLBARS_MODEL (shell->priv->toolbars_model)); } return G_OBJECT (shell->priv->toolbars_model); } } GObject * ephy_shell_get_extensions_manager (EphyShell *es) { g_return_val_if_fail (EPHY_IS_SHELL (es), NULL); if (es->priv->extensions_manager == NULL) { /* Instantiate extensions manager */ es->priv->extensions_manager = g_object_new (EPHY_TYPE_EXTENSIONS_MANAGER, NULL); ephy_extensions_manager_startup (es->priv->extensions_manager); /* FIXME */ ephy_shell_get_lockdown (es); } return G_OBJECT (es->priv->extensions_manager); } static void toolwindow_show_cb (GtkWidget *widget, EphyShell *es) { EphySession *session; LOG ("Ref shell for %s", G_OBJECT_TYPE_NAME (widget)); session = EPHY_SESSION (ephy_shell_get_session (es)); ephy_session_add_window (ephy_shell->priv->session, GTK_WINDOW (widget)); g_object_ref (ephy_shell); } static void toolwindow_hide_cb (GtkWidget *widget, EphyShell *es) { EphySession *session; LOG ("Unref shell for %s", G_OBJECT_TYPE_NAME (widget)); session = EPHY_SESSION (ephy_shell_get_session (es)); ephy_session_remove_window (ephy_shell->priv->session, GTK_WINDOW (widget)); g_object_unref (ephy_shell); } GtkWidget * ephy_shell_get_bookmarks_editor (EphyShell *shell) { EphyBookmarks *bookmarks; if (shell->priv->bme == NULL) { bookmarks = ephy_shell_get_bookmarks (ephy_shell); g_assert (bookmarks != NULL); shell->priv->bme = ephy_bookmarks_editor_new (bookmarks); g_signal_connect (shell->priv->bme, "show", G_CALLBACK (toolwindow_show_cb), shell); g_signal_connect (shell->priv->bme, "hide", G_CALLBACK (toolwindow_hide_cb), shell); } return shell->priv->bme; } GtkWidget * ephy_shell_get_history_window (EphyShell *shell) { EphyHistory *history; if (shell->priv->history_window == NULL) { history = EPHY_HISTORY (ephy_embed_shell_get_global_history (embed_shell)); g_assert (history != NULL); shell->priv->history_window = ephy_history_window_new (history); g_signal_connect (shell->priv->history_window, "show", G_CALLBACK (toolwindow_show_cb), shell); g_signal_connect (shell->priv->history_window, "hide", G_CALLBACK (toolwindow_hide_cb), shell); } return shell->priv->history_window; } GObject * ephy_shell_get_pdm_dialog (EphyShell *shell) { if (shell->priv->pdm_dialog == NULL) { shell->priv->pdm_dialog = g_object_new (EPHY_TYPE_PDM_DIALOG, NULL); g_object_add_weak_pointer (shell->priv->pdm_dialog, (gpointer *) &shell->priv->pdm_dialog); } return shell->priv->pdm_dialog; } GObject * ephy_shell_get_prefs_dialog (EphyShell *shell) { if (shell->priv->prefs_dialog == NULL) { shell->priv->prefs_dialog = g_object_new (EPHY_TYPE_PREFS_DIALOG, NULL); g_object_add_weak_pointer (shell->priv->prefs_dialog, (gpointer *) &shell->priv->prefs_dialog); } return shell->priv->prefs_dialog; } GObject * ephy_shell_get_print_setup_dialog (EphyShell *shell) { if (shell->priv->print_setup_dialog == NULL) { shell->priv->print_setup_dialog = G_OBJECT (ephy_print_setup_dialog_new ()); g_object_add_weak_pointer (shell->priv->print_setup_dialog, (gpointer *) &shell->priv->print_setup_dialog); } return shell->priv->print_setup_dialog; } GObject * ephy_shell_get_dbus_service (EphyShell *shell) { g_return_val_if_fail (EPHY_IS_SHELL (shell), NULL); if (shell->priv->dbus_service == NULL) { shell->priv->dbus_service = g_object_new (EPHY_TYPE_DBUS, NULL); ephy_dbus_startup (EPHY_DBUS (shell->priv->dbus_service)); } return G_OBJECT (shell->priv->dbus_service); }