From 768eae4a4874a7fe0eada98423f61d84f6416bde Mon Sep 17 00:00:00 2001 From: Marco Pesenti Gritti Date: Wed, 5 Feb 2003 20:28:09 +0000 Subject: *** empty log message *** --- embed/mozilla/mozilla-embed-single.cpp | 958 +++++++++++++++++++++++++++++++++ 1 file changed, 958 insertions(+) create mode 100644 embed/mozilla/mozilla-embed-single.cpp (limited to 'embed/mozilla/mozilla-embed-single.cpp') diff --git a/embed/mozilla/mozilla-embed-single.cpp b/embed/mozilla/mozilla-embed-single.cpp new file mode 100644 index 000000000..fe1fbd1f0 --- /dev/null +++ b/embed/mozilla/mozilla-embed-single.cpp @@ -0,0 +1,958 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * 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. + */ + +#include "glib.h" +#include "ephy-string.h" +#include "gtkmozembed.h" +#include "mozilla-embed-single.h" +#include "mozilla-prefs.h" +#include "ephy-prefs.h" +#include "ephy-file-helpers.h" +#include "mozilla-notifiers.h" +#include "mozilla-i18n.h" +#include "eel-gconf-extensions.h" +#include "ephy-embed-prefs.h" +#include "MozRegisterComponents.h" +#include "FilePicker.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MOZILLA_PROFILE_DIR "/mozilla" +#define MOZILLA_PROFILE_NAME "epiphany" +#define MOZILLA_PROFILE_FILE "prefs.js" + +static void +mozilla_embed_single_class_init (MozillaEmbedSingleClass *klass); +static void +mozilla_embed_single_init (MozillaEmbedSingle *ges); +static void +mozilla_embed_single_finalize (GObject *object); + +static gresult +impl_clear_cache (EphyEmbedSingle *shell, + CacheType type); +static gresult +impl_set_offline_mode (EphyEmbedSingle *shell, + gboolean offline); +static gresult +impl_load_proxy_autoconf (EphyEmbedSingle *shell, + const char* url); +static gresult +impl_get_charset_titles (EphyEmbedSingle *shell, + const char *group, + GList **charsets); +static gresult +impl_get_charset_groups (EphyEmbedSingle *shell, + GList **groups); +static gresult +impl_get_font_list (EphyEmbedSingle *shell, + const char *langGroup, + const char *fontType, + GList **fontList, + char **default_font); +static gresult +impl_list_cookies (EphyEmbedSingle *shell, + GList **cookies); +static gresult +impl_remove_cookies (EphyEmbedSingle *shell, + GList *cookies); +static gresult +impl_list_passwords (EphyEmbedSingle *shell, + PasswordType type, + GList **passwords); +static gresult +impl_remove_passwords (EphyEmbedSingle *shell, + GList *passwords, + PasswordType type); +static gresult +impl_show_file_picker (EphyEmbedSingle *shell, + GtkWidget *parentWidget, + const char *title, + const char *directory, + const char *file, + FilePickerMode mode, + char **ret_fullpath, + gboolean *ret_save_content, + FileFormat *file_formats, + int *ret_file_format); + +static void mozilla_embed_single_new_window_orphan_cb (GtkMozEmbedSingle *embed, + GtkMozEmbed **retval, + guint chrome_mask, + EphyEmbedSingle *shell); + +struct MozillaEmbedSinglePrivate +{ + char *user_prefs; + GHashTable *charsets_hash; + GList *sorted_charsets_titles; +}; + +static NS_DEFINE_CID(kJVMManagerCID, NS_JVMMANAGER_CID); + +static GObjectClass *parent_class = NULL; + +GType +mozilla_embed_single_get_type (void) +{ + static GType mozilla_embed_single_type = 0; + + if (mozilla_embed_single_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (MozillaEmbedSingleClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) mozilla_embed_single_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (MozillaEmbedSingle), + 0, /* n_preallocs */ + (GInstanceInitFunc) mozilla_embed_single_init + }; + + mozilla_embed_single_type = g_type_register_static (EPHY_EMBED_SINGLE_TYPE, + "MozillaEmbedSingle", + &our_info, (GTypeFlags)0); + } + + return mozilla_embed_single_type; +} + +static void +mozilla_embed_single_class_init (MozillaEmbedSingleClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + EphyEmbedSingleClass *shell_class; + + parent_class = (GObjectClass *) g_type_class_peek_parent (klass); + shell_class = EPHY_EMBED_SINGLE_CLASS (klass); + + object_class->finalize = mozilla_embed_single_finalize; + + shell_class->clear_cache = impl_clear_cache; + shell_class->set_offline_mode = impl_set_offline_mode; + shell_class->load_proxy_autoconf = impl_load_proxy_autoconf; + shell_class->get_charset_titles = impl_get_charset_titles; + shell_class->get_charset_groups = impl_get_charset_groups; + shell_class->get_font_list = impl_get_font_list; + shell_class->list_cookies = impl_list_cookies; + shell_class->remove_cookies = impl_remove_cookies; + shell_class->list_passwords = impl_list_passwords; + shell_class->remove_passwords = impl_remove_passwords; + shell_class->show_file_picker = impl_show_file_picker; +} + +static void +mozilla_load_proxy_prefs (MozillaEmbedSingle *shell) +{ + char *tmp; + int i, mozilla_mode = 0; + + /* Proxy mode */ + tmp = eel_gconf_get_string (CONF_NETWORK_PROXY_MODE); + g_return_if_fail (tmp != NULL); + + if (strcmp (tmp, "manual") == 0) + { + mozilla_mode = 1; + } + else if (strcmp (tmp, "auto") == 0) + { + mozilla_mode = 2; + } + + mozilla_prefs_set_int ("network.proxy.type", mozilla_mode); + g_free (tmp); + + /* Http proxy */ + tmp = eel_gconf_get_string (CONF_NETWORK_HTTP_PROXY); + g_return_if_fail (tmp != NULL); + mozilla_prefs_set_string ("network.proxy.http", tmp); + g_free (tmp); + + i = eel_gconf_get_integer (CONF_NETWORK_HTTP_PROXY_PORT); + mozilla_prefs_set_int ("network.proxy.http_port", i); + + /* Ftp proxy */ + tmp = eel_gconf_get_string (CONF_NETWORK_FTP_PROXY); + g_return_if_fail (tmp != NULL); + mozilla_prefs_set_string ("network.proxy.ftp", tmp); + g_free (tmp); + + i = eel_gconf_get_integer (CONF_NETWORK_FTP_PROXY_PORT); + mozilla_prefs_set_int ("network.proxy.ftp_port", i); + + /* Secure proxy */ + tmp = eel_gconf_get_string (CONF_NETWORK_SSL_PROXY); + g_return_if_fail (tmp != NULL); + mozilla_prefs_set_string ("network.proxy.ssl", tmp); + g_free (tmp); + + i = eel_gconf_get_integer (CONF_NETWORK_SSL_PROXY_PORT); + mozilla_prefs_set_int ("network.proxy.ssl_port", i); + + /* Socks proxy */ + tmp = eel_gconf_get_string (CONF_NETWORK_SOCKS_PROXY); + g_return_if_fail (tmp != NULL); + mozilla_prefs_set_string ("network.proxy.socks", tmp); + g_free (tmp); + + i = eel_gconf_get_integer (CONF_NETWORK_SOCKS_PROXY_PORT); + mozilla_prefs_set_int ("network.proxy.socks_port", i); + + /* Autoconfiguration */ + tmp = eel_gconf_get_string (CONF_NETWORK_PROXY_AUTO_URL); + g_return_if_fail (tmp != NULL); + ephy_embed_single_load_proxy_autoconf + (EPHY_EMBED_SINGLE (shell), tmp); + g_free (tmp); +} + +static void +mozilla_set_default_prefs (MozillaEmbedSingle *mes) +{ + mozilla_prefs_load (ephy_file ("default-prefs.js")); + mozilla_prefs_save (mes->priv->user_prefs); +} + +static void +mozilla_init_single (MozillaEmbedSingle *mes) +{ + GtkMozEmbedSingle *single; + + /* get single */ + single = gtk_moz_embed_single_get (); + if (single == NULL) + { + g_warning ("Failed to get singleton embed object!\n"); + } + + /* allow creation of orphan windows */ + g_signal_connect (G_OBJECT (single), "new_window_orphan", + GTK_SIGNAL_FUNC (mozilla_embed_single_new_window_orphan_cb), + mes); +} + +static void +mozilla_init_home (void) +{ + char *mozilla_five_home; + mozilla_five_home = g_strdup (g_getenv ("MOZILLA_FIVE_HOME")); + gtk_moz_embed_set_comp_path (mozilla_five_home); + g_free (mozilla_five_home); +} + +void +mozilla_init_profile (void) +{ + char *profile_path; + profile_path = g_build_filename (ephy_dot_dir (), + MOZILLA_PROFILE_DIR, + NULL); + gtk_moz_embed_set_profile_path (profile_path, MOZILLA_PROFILE_NAME); + g_free (profile_path); +} + +static gboolean +is_new_build (MozillaEmbedSingle *mes) +{ + gboolean new_build = FALSE; + char *build_test; + char *prefs_file; + + prefs_file = g_build_filename (ephy_dot_dir (), + MOZILLA_PROFILE_DIR, + MOZILLA_PROFILE_NAME, + MOZILLA_PROFILE_FILE, + NULL); + + /* no mozilla prefs ? or new epiphany build */ + build_test = eel_gconf_get_string ("/apps/epiphany/gconf_test"); + if (!g_file_test(mes->priv->user_prefs, G_FILE_TEST_EXISTS) || + build_test == NULL || + strncmp (build_test, __TIME__, 8) != 0) + { + new_build = TRUE; + eel_gconf_set_string ("/apps/epiphany/gconf_test", __TIME__); + } + + g_free (build_test); + + return new_build; +} + +static void +mozilla_init_prefs (MozillaEmbedSingle *mes) +{ + mozilla_set_default_prefs (mes); + mozilla_notifiers_set_defaults (); +} + +static gboolean +have_gnome_url_handler (const gchar *protocol) +{ + gchar *key, *cmd; + gboolean rv; + + key = g_strdup_printf ("/desktop/gnome/url-handlers/%s/command", + protocol); + cmd = eel_gconf_get_string (key); + g_free (key); + + rv = (cmd != NULL); + g_free (cmd); + + if (!rv) return rv; + + key = g_strdup_printf ("/desktop/gnome/url-handlers/%s/enabled", + protocol); + rv = eel_gconf_get_boolean (key); + g_free (key); + + return rv; +} + +static void +mozilla_register_external_protocols (void) +{ + /* FIXME register only when needed */ + if (have_gnome_url_handler ("ftp")) + { + mozilla_register_FtpProtocolHandler (); + } + else + { + mozilla_unregister_FtpProtocolHandler (); + } + + mozilla_register_MailtoProtocolHandler (); +} + +static void +mozilla_embed_single_init (MozillaEmbedSingle *mes) +{ + gboolean new_build; + + mes->priv = g_new0 (MozillaEmbedSinglePrivate, 1); + mes->priv->charsets_hash = NULL; + mes->priv->sorted_charsets_titles = NULL; + + mes->priv->user_prefs = + g_build_filename (ephy_dot_dir (), + MOZILLA_PROFILE_DIR, + MOZILLA_PROFILE_NAME, + MOZILLA_PROFILE_FILE, + NULL); + + new_build = is_new_build (mes); + + /* Pre initialization */ + mozilla_notifiers_init (EPHY_EMBED_SINGLE (mes)); + mozilla_init_home (); + mozilla_init_profile (); + + /* Fire up the best */ + gtk_moz_embed_push_startup (); + + /* Post initialization */ + if (new_build) + { + mozilla_init_prefs (mes); + } + + mozilla_load_proxy_prefs (mes); + + mozilla_init_single (mes); + + mozilla_register_components (); + + mozilla_register_external_protocols (); + + /* FIXME alert if fails */ +} + +static void +mozilla_embed_single_new_window_orphan_cb (GtkMozEmbedSingle *embed, + GtkMozEmbed **retval, + guint chrome_mask, + EphyEmbedSingle *shell) +{ + /* FIXME conversion duped in mozilla_embed */ + EphyEmbed *new_embed; + int i; + EmbedChromeMask mask = EMBED_CHROME_OPENASPOPUP; + + struct + { + guint chromemask; + EmbedChromeMask embed_mask; + } + conversion_map [] = + { + { GTK_MOZ_EMBED_FLAG_DEFAULTCHROME, EMBED_CHROME_DEFAULT }, + { GTK_MOZ_EMBED_FLAG_MENUBARON, EMBED_CHROME_MENUBARON }, + { GTK_MOZ_EMBED_FLAG_TOOLBARON, EMBED_CHROME_TOOLBARON }, + { GTK_MOZ_EMBED_FLAG_STATUSBARON, EMBED_CHROME_STATUSBARON }, + { GTK_MOZ_EMBED_FLAG_WINDOWRAISED, EMBED_CHROME_WINDOWRAISED }, + { GTK_MOZ_EMBED_FLAG_WINDOWLOWERED, EMBED_CHROME_WINDOWLOWERED }, + { GTK_MOZ_EMBED_FLAG_CENTERSCREEN, EMBED_CHROME_CENTERSCREEN }, + { GTK_MOZ_EMBED_FLAG_OPENASDIALOG, EMBED_CHROME_OPENASDIALOG }, + { GTK_MOZ_EMBED_FLAG_OPENASCHROME, EMBED_CHROME_OPENASCHROME }, + { 0, EMBED_CHROME_NONE } + }; + + for (i = 0; conversion_map[i].chromemask != 0; i++) + { + if (chrome_mask & conversion_map[i].chromemask) + { + mask = (EmbedChromeMask) (mask | conversion_map[i].embed_mask); + } + } + + g_signal_emit_by_name (shell, "new_window_orphan", &new_embed, mask); + + g_assert (new_embed != NULL); + + *retval = GTK_MOZ_EMBED(EPHY_EMBED(new_embed)); +} + +static void +mozilla_embed_single_finalize (GObject *object) +{ + MozillaEmbedSingle *mes; + + /* Destroy EphyEmbedSingle before because some + * services depend on xpcom */ + G_OBJECT_CLASS (parent_class)->finalize (object); + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_MOZILLA_EMBED_SINGLE (object)); + + mes = MOZILLA_EMBED_SINGLE (object); + + g_return_if_fail (mes->priv != NULL); + + mozilla_notifiers_free (); + + mozilla_prefs_save (mes->priv->user_prefs); + + gtk_moz_embed_pop_startup (); + + g_free (mes->priv->user_prefs); + + g_free (mes->priv); +} + +static gresult +impl_clear_cache (EphyEmbedSingle *shell, + CacheType type) +{ + nsresult rv; + + nsCOMPtr CacheService = + do_GetService (NS_CACHESERVICE_CONTRACTID, &rv); + if (NS_FAILED(rv)) return G_FAILED; + + CacheService->EvictEntries((guint)type); + + return G_OK; +} + +static gresult +impl_set_offline_mode (EphyEmbedSingle *shell, + gboolean offline) +{ + nsresult rv; + + nsCOMPtr io = do_GetService(NS_IOSERVICE_CONTRACTID, &rv); + if (NS_FAILED(rv)) + return G_FAILED; + + rv = io->SetOffline(offline); + if (NS_SUCCEEDED(rv)) return G_FAILED; + + return G_OK; +} + +static gresult +impl_load_proxy_autoconf (EphyEmbedSingle *shell, + const char* url) +{ + nsresult rv; + + nsCOMPtr pps = + do_GetService ("@mozilla.org/network/protocol-proxy-service;1", + &rv); + if (NS_FAILED(rv) || !pps) return G_FAILED; + + rv = pps->ConfigureFromPAC (url); + if (NS_FAILED(rv)) return G_FAILED; + + return G_OK; +} + +static gresult +fill_charsets_lists (MozillaEmbedSinglePrivate *priv) +{ + nsresult rv; + char *tmp; + PRUint32 cscount; + PRUint32 translated_cscount = get_translated_cscount (); + char *charset_str, *charset_title_str; + + nsCOMPtr docCharsetAtom; + nsCOMPtr ccm2 = + do_GetService (NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv); + if (!NS_SUCCEEDED(rv)) return G_FAILED; + + nsCOMPtr cs_list; + rv = ccm2->GetDecoderList (getter_AddRefs(cs_list)); + if (!NS_SUCCEEDED(rv)) return G_FAILED; + + rv = cs_list->Count(&cscount); + priv->charsets_hash = g_hash_table_new (g_str_hash, g_str_equal); + for (PRUint32 i = 0; i < cscount; i++) + { + nsCOMPtr cssupports = + (dont_AddRef)(cs_list->ElementAt(i)); + nsCOMPtr csatom ( do_QueryInterface(cssupports) ); + nsAutoString charset_ns, charset_title_ns; + + /* charset name */ + rv = csatom->ToString(charset_ns); + tmp = ToNewCString (charset_ns); + if (tmp == NULL || strlen (tmp) == 0) + { + continue; + } + charset_str = g_strdup (tmp); + nsMemory::Free (tmp); + tmp = nsnull; + + /* charset readable title */ + rv = ccm2->GetCharsetTitle2(csatom, &charset_title_ns); + tmp = ToNewCString (charset_title_ns); + if (tmp == NULL || + strlen (tmp) == 0) + { + if (tmp) nsMemory::Free (tmp); + charset_title_str = g_strdup (charset_str); + } + else + { + charset_title_str = g_strdup (tmp); + nsMemory::Free (tmp); + tmp = nsnull; + } + + for (PRUint32 j = 0; j < translated_cscount; j++) + { + if (g_ascii_strcasecmp ( + charset_str, + charset_trans_array[j].charset_name) == 0) + { + g_free (charset_title_str); + charset_title_str = (char *) + _(charset_trans_array[j].charset_title); + break; + } + } + + /* fill the hash and the sorted list */ + g_hash_table_insert (priv->charsets_hash, charset_title_str, charset_str); + priv->sorted_charsets_titles = + g_list_insert_sorted (priv->sorted_charsets_titles, + (gpointer)charset_title_str, + (GCompareFunc)g_ascii_strcasecmp); + } + + return G_OK; +} + +static void +ensure_charsets_tables (MozillaEmbedSingle *shell) +{ + if (!shell->priv->charsets_hash) + { + fill_charsets_lists (shell->priv); + } +} + +static gresult +impl_get_charset_titles (EphyEmbedSingle *shell, + const char *group, + GList **charsets) +{ + MozillaEmbedSingle *mshell = MOZILLA_EMBED_SINGLE(shell); + int count = get_translated_cscount (); + GList *l = NULL; + int j; + + ensure_charsets_tables (mshell); + g_return_val_if_fail (mshell->priv->charsets_hash != NULL, G_FAILED); + + for (j = 0; j < count; j++) + { + if (group == NULL || + strcmp (group, lgroups[charset_trans_array[j].lgroup]) == 0) + { + CharsetInfo *info; + info = g_new0 (CharsetInfo, 1); + info->name = charset_trans_array[j].charset_name; + info->title = charset_trans_array[j].charset_title; + l = g_list_append (l, info); + + /* FIXME check that the encoding exists in mozilla before + * adding it */ + } + } + + *charsets = l; + + return G_OK; +} + +static gresult +impl_get_charset_groups (EphyEmbedSingle *shell, + GList **groups) +{ + GList *l = NULL; + int i; + + for (i = 0; lgroups[i] != NULL; i++) + { + l = g_list_append (l, (gpointer)lgroups[i]); + } + + *groups = l; + + return G_OK; +} + +static gresult +impl_get_font_list (EphyEmbedSingle *shell, + const char *langGroup, + const char *fontType, + GList **fontList, + char **default_font) +{ + nsresult rv; + + nsCOMPtr mozFontList; + mozFontList = do_CreateInstance("@mozilla.org/gfx/fontlist;1", &rv); + if(NS_FAILED(rv)) return G_FAILED; + + nsCOMPtr fontEnum; + mozFontList->AvailableFonts(NS_ConvertUTF8toUCS2(langGroup).get(), + NS_ConvertUTF8toUCS2(fontType).get(), + getter_AddRefs(fontEnum)); + if(NS_FAILED(rv)) return G_FAILED; + + GList *l = NULL; + PRBool enumResult; + for(fontEnum->HasMoreElements(&enumResult) ; + enumResult == PR_TRUE; + fontEnum->HasMoreElements(&enumResult)) + { + nsCOMPtr fontName; + fontEnum->GetNext(getter_AddRefs(fontName)); + if(NS_FAILED(rv)) return G_FAILED; + + nsString fontString; + fontName->GetData(fontString); + + char *gFontString; + gFontString = g_strdup(NS_ConvertUCS2toUTF8(fontString).get()); + l = g_list_append(l, gFontString); + } + *fontList = l; + + if (default_font != NULL) + { + char key [255]; + + sprintf (key, "font.name.%s.%s", fontType, langGroup); + + *default_font = mozilla_prefs_get_string (key); + } + + return G_OK; +} + +static gresult +impl_list_cookies (EphyEmbedSingle *shell, + GList **cookies) +{ + nsresult result; + + nsCOMPtr cookieManager = + do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID); + nsCOMPtr cookieEnumerator; + result = + cookieManager->GetEnumerator (getter_AddRefs(cookieEnumerator)); + if (NS_FAILED(result)) return G_FAILED; + + PRBool enumResult; + for (cookieEnumerator->HasMoreElements(&enumResult) ; + enumResult == PR_TRUE ; + cookieEnumerator->HasMoreElements(&enumResult)) + { + CookieInfo *c; + + nsCOMPtr nsCookie; + result = cookieEnumerator->GetNext (getter_AddRefs(nsCookie)); + if (NS_FAILED(result)) return G_FAILED; + + c = g_new0 (CookieInfo, 1); + + nsCAutoString transfer; + + nsCookie->GetHost (transfer); + c->domain = g_strdup (transfer.get()); + nsCookie->GetName (transfer); + c->name = g_strdup (transfer.get()); + nsCookie->GetValue (transfer); + c->value = g_strdup (transfer.get()); + nsCookie->GetPath (transfer); + c->path = g_strdup (transfer.get()); + + PRBool isSecure; + nsCookie->GetIsSecure (&isSecure); + if (isSecure == PR_TRUE) + c->secure = g_strdup (_("Yes")); + else + c->secure = g_strdup (_("No")); + + PRUint64 dateTime; + nsCookie->GetExpires (&dateTime); + if(dateTime == 0) + c->expire = g_strdup (_("End of current session")); + else + c->expire = g_strdup_printf ("%s",ctime((time_t*)&dateTime)); + + *cookies = g_list_prepend (*cookies, c); + } + + *cookies = g_list_reverse (*cookies); + + return G_OK; +} + +static gresult +impl_remove_cookies (EphyEmbedSingle *shell, + GList *cookies) +{ + nsresult result; + GList *cl; + nsCOMPtr cookieManager = + do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID); + + for (cl = g_list_first(cookies) ; cl != NULL ; + cl = g_list_next (cl)) + { + CookieInfo *c = (CookieInfo *)cl->data; + + result = cookieManager->Remove (NS_LITERAL_CSTRING(c->domain), + NS_LITERAL_CSTRING(c->name), + NS_LITERAL_CSTRING(c->path), + PR_FALSE); + if (NS_FAILED(result)) return G_FAILED; + }; + + return G_OK; +} + +static gresult +impl_list_passwords (EphyEmbedSingle *shell, + PasswordType type, + GList **passwords) +{ + nsresult result = NS_ERROR_FAILURE; + + nsCOMPtr passwordManager = + do_CreateInstance (NS_PASSWORDMANAGER_CONTRACTID); + nsCOMPtr passwordEnumerator; + if (type == PASSWORD_PASSWORD) + result = passwordManager->GetEnumerator + (getter_AddRefs(passwordEnumerator)); + else if (type == PASSWORD_REJECT) + result = passwordManager->GetRejectEnumerator + (getter_AddRefs(passwordEnumerator)); + if (NS_FAILED(result)) return G_FAILED; + + PRBool enumResult; + for (passwordEnumerator->HasMoreElements(&enumResult) ; + enumResult == PR_TRUE ; + passwordEnumerator->HasMoreElements(&enumResult)) + { + nsCOMPtr nsPassword; + result = passwordEnumerator->GetNext + (getter_AddRefs(nsPassword)); + if (NS_FAILED(result)) return G_FAILED; + + PasswordInfo *p = g_new0 (PasswordInfo, 1); + + nsCAutoString transfer; + nsPassword->GetHost (transfer); + p->host = g_strdup (transfer.get()); + + if (type == PASSWORD_PASSWORD) + { + nsAutoString unicodeName; + nsPassword->GetUser (unicodeName); + p->username = g_strdup(NS_ConvertUCS2toUTF8(unicodeName).get()); + } + + *passwords = g_list_prepend (*passwords, p); + } + + *passwords = g_list_reverse (*passwords); + + return G_OK; +} + +static gresult +impl_remove_passwords (EphyEmbedSingle *shell, + GList *passwords, + PasswordType type) +{ + nsresult result = NS_ERROR_FAILURE; + nsCOMPtr passwordManager = + do_CreateInstance (NS_PASSWORDMANAGER_CONTRACTID); + + for (GList *l = g_list_first(passwords) ; l !=NULL ; + l = g_list_next(l)) + { + PasswordInfo *p = (PasswordInfo *)l->data; + if (type == PASSWORD_PASSWORD) + { + result = passwordManager->RemoveUser (NS_LITERAL_CSTRING(p->host), + NS_ConvertUTF8toUCS2(nsDependentCString(p->username))); + } + else if (type == PASSWORD_REJECT) + { + result = passwordManager->RemoveReject + (nsDependentCString(p->host)); + }; + + if (NS_FAILED(result)) return G_FAILED; + }; + + return G_OK; +} + +static gresult +impl_show_file_picker (EphyEmbedSingle *shell, + GtkWidget *parentWidget, + const char *title, + const char *directory, + const char *file, + FilePickerMode mode, + char **ret_fullpath, + gboolean *ret_save_content, + FileFormat *file_formats, + int *ret_file_format) +{ + PRBool showContentCheck; + gchar *expanded_directory; + + if (ret_save_content == NULL) + showContentCheck = PR_FALSE; + else + showContentCheck = PR_TRUE; + + GFilePicker *filePicker = new GFilePicker (showContentCheck, + file_formats); + + /* FIXME sane path: expand tilde ... */ + expanded_directory = g_strdup (directory); + + /* make sure the directory exists, and use the home directory + * otherwise */ + if (!expanded_directory || + !g_file_test (expanded_directory, G_FILE_TEST_IS_DIR)) + { + if (expanded_directory) g_free (expanded_directory); + expanded_directory = g_strdup (g_get_home_dir()); + } + + nsCOMPtr dir = + do_CreateInstance (NS_LOCAL_FILE_CONTRACTID); + dir->InitWithNativePath (nsDependentCString(expanded_directory)); + g_free (expanded_directory); + + filePicker->InitWithGtkWidget (parentWidget, title, mode); + filePicker->SetDefaultString (NS_ConvertUTF8toUCS2(file).get()); + filePicker->SetDisplayDirectory (dir); + + PRInt16 retval; + filePicker->Show (&retval); + + if (ret_save_content != NULL) + { + if (retval == GFilePicker::returnOKSaveContent) + *ret_save_content = TRUE; + else + *ret_save_content = FALSE; + } + if (ret_file_format != NULL) + { + *ret_file_format = filePicker->mSelectedFileFormat; + } + + if (retval == nsIFilePicker::returnCancel) + { + delete filePicker; + return G_FAILED; + } + else + { + if (*ret_fullpath) + g_free (*ret_fullpath); + nsCOMPtr file; + filePicker->GetFile (getter_AddRefs(file)); + nsCAutoString tempFullPathStr; + file->GetNativePath (tempFullPathStr); + *ret_fullpath = g_strdup (tempFullPathStr.get()); + delete filePicker; + return G_OK; + } +} -- cgit v1.2.3