sugar-toolkit-gtk3/lib/src/sugar-browser.cpp

/*
 * Copyright (C) 2006, Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <config.h>

#include "sugar-browser.h"
#include "sugar-marshal.h"
#include "GeckoContentHandler.h"
#include "GeckoDownload.h"

#include <gtkmozembed_internal.h>
#include <nsCOMPtr.h>
#include <nsIPrefService.h>
#include <nsServiceManagerUtils.h>
#include <nsStringAPI.h>
#include <nsILocalFile.h>
#include <nsIWebBrowser.h>
#include <nsIWebBrowserFocus.h>
#include <nsIWebBrowserPersist.h>
#include <nsIDOMWindow.h>
#include <nsIDOMWindowUtils.h>
#include <nsIDOMDocument.h>
#include <nsIDOMMouseEvent.h>
#include <nsIGenericFactory.h>
#include <nsIHelperAppLauncherDialog.h>
#include <nsIComponentRegistrar.h>
#include <nsIDOMNode.h>
#include <nsIDOMEventTarget.h>
#include <nsIDOMHTMLImageElement.h>
#include <nsIIOService.h>
#include <nsComponentManagerUtils.h>
#include <imgICache.h>
#include <nsIProperties.h>
#include <nsIWebNavigation.h>
#include <nsISupportsPrimitives.h>
#include <nsIInterfaceRequestorUtils.h>
#include <nsIMIMEHeaderParam.h>
#include <nsISHistory.h>
#include <nsIHistoryEntry.h>
#include <nsISHEntry.h>
#include <nsIInputStream.h>

enum {
	PROP_0,
	PROP_PROGRESS,
	PROP_TITLE,
	PROP_ADDRESS,
	PROP_CAN_GO_BACK,
	PROP_CAN_GO_FORWARD,
	PROP_LOADING,
    PROP_DOCUMENT_METADATA
};

enum {
    MOUSE_CLICK,
    N_SIGNALS
};

static guint signals[N_SIGNALS];

static const nsModuleComponentInfo sSugarComponents[] = {
	{
		"Gecko Content Handler",
		GECKOCONTENTHANDLER_CID,
		NS_IHELPERAPPLAUNCHERDLG_CONTRACTID,
		NULL
	},
	{
		"Gecko Download",
		GECKODOWNLOAD_CID,
		NS_TRANSFER_CONTRACTID,
		NULL
	}
};

static void
setup_plugin_path ()
{
    const char *user_path;
    char *new_path;

    user_path = g_getenv ("MOZ_PLUGIN_PATH");
    new_path = g_strconcat (user_path ? user_path : "",
                            user_path ? ":" : "",
                            PLUGIN_DIR,
                            (char *) NULL);
    g_setenv ("MOZ_PLUGIN_PATH", new_path, TRUE);
    g_free (new_path);
}

gboolean
sugar_browser_startup(const char *profile_path, const char *profile_name)
{
	nsresult rv;

    setup_plugin_path();

	gtk_moz_embed_set_profile_path(profile_path, profile_name);

    gtk_moz_embed_push_startup();

	nsCOMPtr<nsIPrefService> prefService;
	prefService = do_GetService(NS_PREFSERVICE_CONTRACTID);
	NS_ENSURE_TRUE(prefService, FALSE);

	/* Read our predefined default prefs */
	nsCOMPtr<nsILocalFile> file;
	NS_NewNativeLocalFile(nsCString(SHARE_DIR"/gecko-prefs.js"),
						  PR_TRUE, getter_AddRefs(file));
	NS_ENSURE_TRUE(file, FALSE);

	rv = prefService->ReadUserPrefs (file);
	if (NS_FAILED(rv)) {
		g_warning ("failed to read default preferences, error: %x", rv);
		return FALSE;
	}

	nsCOMPtr<nsIPrefBranch> pref;
	prefService->GetBranch ("", getter_AddRefs(pref));
	NS_ENSURE_TRUE(pref, FALSE);

    pref->SetCharPref ("helpers.private_mime_types_file", SHARE_DIR"/mime.types");

	rv = prefService->ReadUserPrefs (nsnull);
	if (NS_FAILED(rv)) {
		g_warning ("failed to read user preferences, error: %x", rv);
	}

	nsCOMPtr<nsIComponentRegistrar> componentRegistrar;
	NS_GetComponentRegistrar(getter_AddRefs(componentRegistrar));
	NS_ENSURE_TRUE (componentRegistrar, FALSE);

    nsCOMPtr<nsIFactory> contentHandlerFactory;
    rv = NS_NewGeckoContentHandlerFactory(getter_AddRefs(contentHandlerFactory));
    rv = componentRegistrar->RegisterFactory(sSugarComponents[0].mCID,
                                             sSugarComponents[0].mDescription,
                                             sSugarComponents[0].mContractID,
                                             contentHandlerFactory);
	if (NS_FAILED(rv)) {
		g_warning ("Failed to register factory for %s\n", sSugarComponents[0].mDescription);
		return FALSE;
	}

    nsCOMPtr<nsIFactory> downloadFactory;
    rv = NS_NewGeckoDownloadFactory(getter_AddRefs(downloadFactory));
    rv = componentRegistrar->RegisterFactory(sSugarComponents[1].mCID,
                                             sSugarComponents[1].mDescription,
                                             sSugarComponents[1].mContractID,
                                             downloadFactory);
	if (NS_FAILED(rv)) {
		g_warning ("Failed to register factory for %s\n", sSugarComponents[1].mDescription);
		return FALSE;
	}

	return TRUE;
}

void
sugar_browser_shutdown(void)
{
    gtk_moz_embed_pop_startup();
}

G_DEFINE_TYPE(SugarBrowser, sugar_browser, GTK_TYPE_MOZ_EMBED)

static nsresult
NewURI(const char *uri, nsIURI **result)
{
    nsresult rv;

    nsCOMPtr<nsIServiceManager> mgr;
    NS_GetServiceManager (getter_AddRefs (mgr));
    NS_ENSURE_TRUE(mgr, FALSE);

    nsCOMPtr<nsIIOService> ioService;
    rv = mgr->GetServiceByContractID ("@mozilla.org/network/io-service;1",
                                      NS_GET_IID (nsIIOService),
                                      getter_AddRefs(ioService));
    NS_ENSURE_SUCCESS(rv, FALSE);

    nsCString cSpec(uri);
    return ioService->NewURI (cSpec, nsnull, nsnull, result);
}

static nsresult
FilenameFromContentDisposition(nsCString contentDisposition, nsCString &fileName)
{
    nsresult rv;

    nsCString fallbackCharset;

    nsCOMPtr<nsIMIMEHeaderParam> mimehdrpar =
        do_GetService("@mozilla.org/network/mime-hdrparam;1");
    NS_ENSURE_TRUE(mimehdrpar, NS_ERROR_FAILURE);

    nsString aFileName;
    rv = mimehdrpar->GetParameter (contentDisposition, "filename",
                                   fallbackCharset, PR_TRUE, nsnull,
                                   aFileName);

    if (NS_FAILED(rv) || !fileName.Length()) {
        rv = mimehdrpar->GetParameter (contentDisposition, "name",
                                       fallbackCharset, PR_TRUE, nsnull,
                                       aFileName);
    }

    if (NS_SUCCEEDED(rv) && fileName.Length()) {
        NS_UTF16ToCString (aFileName, NS_CSTRING_ENCODING_UTF8, fileName);
    }

    return NS_OK;
}

static nsresult
ImageNameFromCache(nsIURI *imgURI, nsCString &imgName)
{
    nsresult rv;

    nsCOMPtr<nsIServiceManager> mgr;
    NS_GetServiceManager (getter_AddRefs (mgr));
    NS_ENSURE_TRUE(mgr, NS_ERROR_FAILURE);

    nsCOMPtr<imgICache> imgCache;
    rv = mgr->GetServiceByContractID("@mozilla.org/image/cache;1",
                                     NS_GET_IID (imgICache),
                                     getter_AddRefs(imgCache));
    NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);

    nsCOMPtr<nsIProperties> imgProperties;
    imgCache->FindEntryProperties(imgURI, getter_AddRefs(imgProperties));
    if (imgProperties) {
        nsCOMPtr<nsISupportsCString> dispositionCString;
        imgProperties->Get("content-disposition",
                           NS_GET_IID(nsISupportsCString),
                           getter_AddRefs(dispositionCString));
        if (dispositionCString) {
            nsCString contentDisposition;
            dispositionCString->GetData(contentDisposition);
            FilenameFromContentDisposition(contentDisposition, imgName);
        }
    }

    return NS_OK;
}

static SugarBrowserMetadata *
sugar_browser_get_document_metadata(SugarBrowser *browser)
{
    SugarBrowserMetadata *metadata = sugar_browser_metadata_new();

#ifdef HAVE_NS_WEB_BROWSER
	nsCOMPtr<nsIWebBrowser> webBrowser;
	gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(browser),
									getter_AddRefs(webBrowser));
	NS_ENSURE_TRUE(webBrowser, metadata);

    nsCOMPtr<nsIDOMWindow> DOMWindow;
    webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow));
	NS_ENSURE_TRUE(DOMWindow, metadata);

    nsCOMPtr<nsIDOMWindowUtils> DOMWindowUtils(do_GetInterface(DOMWindow));
	NS_ENSURE_TRUE(DOMWindowUtils, metadata);

    const PRUnichar contentDispositionLiteral[] =
        {'c', 'o', 'n', 't', 'e', 'n', 't', '-', 'd', 'i', 's', 'p',
         'o', 's', 'i', 't', 'i', 'o', 'n', '\0'};

    nsString contentDisposition;
    DOMWindowUtils->GetDocumentMetadata(nsString(contentDispositionLiteral),
                                        contentDisposition);

    nsCString cContentDisposition;
    NS_UTF16ToCString (contentDisposition, NS_CSTRING_ENCODING_UTF8,
                       cContentDisposition);

    nsCString fileName;
    FilenameFromContentDisposition(cContentDisposition, fileName);

    if (!fileName.Length()) {
        nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(webBrowser));
        if (webNav) {
            nsCOMPtr<nsIURI> docURI;
            webNav->GetCurrentURI (getter_AddRefs(docURI));

            nsCOMPtr<nsIURL> url(do_QueryInterface(docURI));
            if (url) {
                url->GetFileName(fileName);
            }
        }
    }

    if (fileName.Length()) {
        metadata->filename = g_strdup(fileName.get());
    }
#endif

    return metadata;
}

static void
sugar_browser_get_property(GObject         *object,
						   guint            prop_id,
						   GValue          *value,
						   GParamSpec      *pspec)
{
	SugarBrowser *browser = SUGAR_BROWSER(object);

	switch (prop_id) {
	    case PROP_PROGRESS:
			g_value_set_double(value, browser->progress);
		break;
	    case PROP_ADDRESS:
			g_value_set_string(value, browser->address);
		break;
	    case PROP_TITLE:
			g_value_set_string(value, browser->title);
		break;
	    case PROP_CAN_GO_BACK:
			g_value_set_boolean(value, browser->can_go_back);
		break;
	    case PROP_CAN_GO_FORWARD:
			g_value_set_boolean(value, browser->can_go_forward);
		break;
	    case PROP_LOADING:
			g_value_set_boolean(value, browser->loading);
		break;
	    case PROP_DOCUMENT_METADATA:
            SugarBrowserMetadata *metadata;
            metadata = sugar_browser_get_document_metadata(browser);
			g_value_set_boxed(value, metadata);
		break;
		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}


static void
sugar_browser_class_init(SugarBrowserClass *browser_class)
{
	GObjectClass *gobject_class = G_OBJECT_CLASS(browser_class);

	gobject_class->get_property = sugar_browser_get_property;

    signals[MOUSE_CLICK] = g_signal_new ("mouse_click",
                                SUGAR_TYPE_BROWSER,
                                G_SIGNAL_RUN_LAST,
                                G_STRUCT_OFFSET(SugarBrowser, mouse_click),
                                g_signal_accumulator_true_handled, NULL,
                                sugar_marshal_BOOLEAN__BOXED,
                                G_TYPE_BOOLEAN,
                                1,
                                SUGAR_TYPE_BROWSER_EVENT);

	g_object_class_install_property(gobject_class, PROP_PROGRESS,
                                    g_param_spec_double ("progress",
                                                         "Progress",
                                                         "Progress",
                                                         0.0, 1.0, 0.0,
                                                         G_PARAM_READABLE));

	g_object_class_install_property (gobject_class, PROP_ADDRESS,
									 g_param_spec_string ("address",
														  "Address",
														  "Address",
                                                          "",
														  G_PARAM_READABLE));

	g_object_class_install_property (gobject_class, PROP_TITLE,
									 g_param_spec_string ("title",
														  "Title",
														  "Title",
                                                          "",
														  G_PARAM_READABLE));

	g_object_class_install_property (gobject_class, PROP_CAN_GO_BACK,
									 g_param_spec_boolean ("can-go-back",
														   "Can go back",
														   "Can go back",
														   FALSE,
														   G_PARAM_READABLE));

	g_object_class_install_property (gobject_class, PROP_CAN_GO_FORWARD,
									 g_param_spec_boolean ("can-go-forward",
														   "Can go forward",
														   "Can go forward",
														   FALSE,
														   G_PARAM_READABLE));

	g_object_class_install_property (gobject_class, PROP_LOADING,
									 g_param_spec_boolean ("loading",
														   "Loading",
														   "Loading",
														   FALSE,
														   G_PARAM_READABLE));

    g_object_class_install_property(gobject_class, PROP_DOCUMENT_METADATA,
                                    g_param_spec_boxed("document-metadata",
                                                       "Document Metadata",
                                                       "Document metadata",
                                                       SUGAR_TYPE_BROWSER_METADATA,
                                                       G_PARAM_READABLE));

}

SugarBrowser *
sugar_browser_create_window(SugarBrowser *browser)
{
	return SUGAR_BROWSER_GET_CLASS(browser)->create_window(browser);
}

static void
update_navigation_properties(SugarBrowser *browser)
{
	GtkMozEmbed *embed = GTK_MOZ_EMBED(browser);
	gboolean can_go_back;
	gboolean can_go_forward;

	can_go_back = gtk_moz_embed_can_go_back(embed);
	if (can_go_back != browser->can_go_back) {
		browser->can_go_back = can_go_back;
		g_object_notify (G_OBJECT(browser), "can-go-back");
	}

	can_go_forward = gtk_moz_embed_can_go_forward(embed);
	if (can_go_forward != browser->can_go_forward) {
		browser->can_go_forward = can_go_forward;
		g_object_notify (G_OBJECT(browser), "can-go-forward");
	}
}

static void
new_window_cb(GtkMozEmbed  *embed,
			  GtkMozEmbed **newEmbed,
              guint         chromemask)
{
	SugarBrowser *browser;

	browser = sugar_browser_create_window(SUGAR_BROWSER(embed));

	*newEmbed = GTK_MOZ_EMBED(browser);
}

static void
sugar_browser_set_progress(SugarBrowser *browser, float progress)
{
	g_return_if_fail(SUGAR_IS_BROWSER(browser));

	browser->progress = progress;
	g_object_notify (G_OBJECT(browser), "progress");
}

static void
sugar_browser_set_loading(SugarBrowser *browser, gboolean loading)
{
	g_return_if_fail(SUGAR_IS_BROWSER(browser));

	browser->loading = loading;
	g_object_notify (G_OBJECT(browser), "loading");
}

static void
net_state_cb(GtkMozEmbed *embed, const char *aURI, gint state, guint status)
{
	SugarBrowser *browser = SUGAR_BROWSER(embed);

	if (state & GTK_MOZ_EMBED_FLAG_IS_NETWORK) {
		if (state & GTK_MOZ_EMBED_FLAG_START) {
			browser->total_requests = 0;
			browser->current_requests = 0;

			sugar_browser_set_progress(browser, 0.03);
			sugar_browser_set_loading(browser, TRUE);
		} else if (state & GTK_MOZ_EMBED_FLAG_STOP) {
			sugar_browser_set_progress(browser, 1.0);
			sugar_browser_set_loading(browser, FALSE);
		}
	}

	if (state & GTK_MOZ_EMBED_FLAG_IS_REQUEST) {
		float progress;

		if (state & GTK_MOZ_EMBED_FLAG_START) {
			browser->total_requests++;
		}
		else if (state & GTK_MOZ_EMBED_FLAG_STOP)
		{
			browser->current_requests++;
		}

		progress = float(browser->current_requests) /
				   float(browser->total_requests);
		if (progress > browser->progress) {
			sugar_browser_set_progress(browser, progress);
		}
	}
}

static void
title_cb(GtkMozEmbed *embed)
{
	SugarBrowser *browser = SUGAR_BROWSER(embed);

	g_free(browser->title);
	browser->title = gtk_moz_embed_get_title(embed);

	g_object_notify (G_OBJECT(browser), "title");
}

static void
location_cb(GtkMozEmbed *embed)
{
	SugarBrowser *browser = SUGAR_BROWSER(embed);

	g_free(browser->address);
	browser->address = gtk_moz_embed_get_location(embed);

	g_object_notify (G_OBJECT(browser), "address");

	update_navigation_properties(browser);
}

static char *
get_image_name(const char *uri)
{
    nsresult rv;

    nsCString imgName;

    nsCOMPtr<nsIURI> imgURI;
    rv = NewURI(uri, getter_AddRefs(imgURI));
    NS_ENSURE_SUCCESS(rv, NULL);

    ImageNameFromCache(imgURI, imgName);

    if (!imgName.Length()) {
        nsCOMPtr<nsIURL> url(do_QueryInterface(imgURI));
        if (url) {
            url->GetFileName(imgName);
        }
    }

    return imgName.Length() ? g_strdup(imgName.get()) : NULL;
}

static gboolean
dom_mouse_click_cb(GtkMozEmbed *embed, nsIDOMMouseEvent *mouseEvent)
{
	SugarBrowser *browser = SUGAR_BROWSER(embed);
    SugarBrowserEvent *event;
    gint return_value = FALSE;

    nsCOMPtr<nsIDOMEventTarget> eventTarget;
    mouseEvent->GetTarget(getter_AddRefs(eventTarget));
    NS_ENSURE_TRUE(mouseEvent, FALSE);

    nsCOMPtr<nsIDOMNode> targetNode;
    targetNode = do_QueryInterface(eventTarget);
    NS_ENSURE_TRUE(targetNode, FALSE);

    event = sugar_browser_event_new();

    nsresult rv;

    PRUint16 type;
    rv = targetNode->GetNodeType(&type);
    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;

    nsCOMPtr<nsIDOMHTMLElement> element = do_QueryInterface(targetNode);
    if ((nsIDOMNode::ELEMENT_NODE == type) && element) {
        nsString uTag;
        rv = element->GetLocalName(uTag);
        if (NS_FAILED(rv)) return NS_ERROR_FAILURE;

        nsCString tag;
        NS_UTF16ToCString (uTag, NS_CSTRING_ENCODING_UTF8, tag);

        if (g_ascii_strcasecmp (tag.get(), "img") == 0) {
            nsString img;

            nsCOMPtr <nsIDOMHTMLImageElement> image;
            image = do_QueryInterface(targetNode, &rv);
            if (NS_FAILED(rv) || !image) return NS_ERROR_FAILURE;

            rv = image->GetSrc(img);
            if (NS_FAILED(rv)) return NS_ERROR_FAILURE;

            nsCString cImg;
            NS_UTF16ToCString (img, NS_CSTRING_ENCODING_UTF8, cImg);
            event->image_uri = g_strdup(cImg.get());
            event->image_name = get_image_name(event->image_uri);
        }
    }

    PRUint16 btn = 0;
    mouseEvent->GetButton (&btn);
    event->button = btn + 1;

    g_signal_emit(browser, signals[MOUSE_CLICK], 0, event, &return_value);

    sugar_browser_event_free(event);

    return return_value;
}

static void
sugar_browser_init(SugarBrowser *browser)
{
	browser->title = NULL;
	browser->address = NULL;
	browser->progress = 0.0;

	g_signal_connect(G_OBJECT(browser), "new-window",
					 G_CALLBACK(new_window_cb), NULL);
	g_signal_connect(G_OBJECT(browser), "net-state-all",
					 G_CALLBACK(net_state_cb), NULL);
	g_signal_connect(G_OBJECT(browser), "title",
					 G_CALLBACK(title_cb), NULL);
	g_signal_connect(G_OBJECT(browser), "location",
					 G_CALLBACK(location_cb), NULL);
	g_signal_connect(G_OBJECT(browser), "dom-mouse-click",
					 G_CALLBACK(dom_mouse_click_cb), NULL);
}

void
sugar_browser_scroll_pixels(SugarBrowser *browser,
                            int           dx,
                            int           dy)
{
#ifndef HAVE_GECKO_1_9
	nsCOMPtr<nsIWebBrowser> webBrowser;
	gtk_moz_embed_get_nsIWebBrowser (GTK_MOZ_EMBED(browser),
									 getter_AddRefs(webBrowser));
	NS_ENSURE_TRUE (webBrowser, );

	nsCOMPtr<nsIWebBrowserFocus> webBrowserFocus;
	webBrowserFocus = do_QueryInterface (webBrowser);
	NS_ENSURE_TRUE (webBrowserFocus, );

	nsCOMPtr<nsIDOMWindow> DOMWindow;
	webBrowserFocus->GetFocusedWindow (getter_AddRefs(DOMWindow));
	if (!DOMWindow) {
		webBrowser->GetContentDOMWindow (getter_AddRefs(DOMWindow));
	}
	NS_ENSURE_TRUE (DOMWindow, );

	DOMWindow->ScrollBy (dx, dy);
#endif
}

void
sugar_browser_grab_focus(SugarBrowser *browser)
{
	GtkWidget *child;

	child = gtk_bin_get_child(GTK_BIN(browser));

	if (child != NULL) {
		gtk_widget_grab_focus (child);
	} else {
		g_warning ("Need to realize the embed before grabbing focus!\n");
	}
}


static nsresult
GetPostData(SugarBrowser *browser, nsIInputStream **postData)
{
#ifdef HAVE_NS_WEB_BROWSER
	nsCOMPtr<nsIWebBrowser> webBrowser;
	gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(browser),
									getter_AddRefs(webBrowser));
	NS_ENSURE_TRUE(webBrowser, NS_ERROR_FAILURE);

    nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(webBrowser));
	NS_ENSURE_TRUE(webNav, NS_ERROR_FAILURE);

    PRInt32 sindex;

    nsCOMPtr<nsISHistory> sessionHistory;
    webNav->GetSessionHistory(getter_AddRefs(sessionHistory));
	NS_ENSURE_TRUE(sessionHistory, NS_ERROR_FAILURE);

    nsCOMPtr<nsIHistoryEntry> entry;
    sessionHistory->GetIndex(&sindex);
    sessionHistory->GetEntryAtIndex(sindex, PR_FALSE, getter_AddRefs(entry));

    nsCOMPtr<nsISHEntry> shEntry(do_QueryInterface(entry));
    if (shEntry) {
        shEntry->GetPostData(postData);
    }

    return NS_OK;
#endif
    return NS_ERROR_NOT_IMPLEMENTED;
}

gboolean
sugar_browser_save_uri(SugarBrowser *browser,
                       const char   *uri,
                       const char   *filename)
{
#ifdef HAVE_NS_WEB_BROWSER
    nsresult rv;

    nsCOMPtr<nsIURI> sourceURI;
    rv = NewURI(uri, getter_AddRefs(sourceURI));
    NS_ENSURE_SUCCESS(rv, FALSE);

    nsCOMPtr<nsILocalFile> destFile = do_CreateInstance("@mozilla.org/file/local;1");
    NS_ENSURE_TRUE(destFile, FALSE);

    destFile->InitWithNativePath(nsCString(filename));

    nsCOMPtr<nsIWebBrowser> webBrowser;
    gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(browser),
                                    getter_AddRefs(webBrowser));
    NS_ENSURE_TRUE(webBrowser, FALSE);

    nsCOMPtr<nsIWebBrowserPersist> webPersist = do_QueryInterface (webBrowser);
    NS_ENSURE_TRUE(webPersist, FALSE);

    nsCOMPtr<nsIInputStream> postData;
    GetPostData(browser, getter_AddRefs(postData));

    rv = webPersist->SaveURI(sourceURI, nsnull, nsnull, postData, nsnull, destFile);
    NS_ENSURE_SUCCESS(rv, FALSE);

    return TRUE;
#else
    return FALSE;
#endif
}

gboolean
sugar_browser_save_document(SugarBrowser *browser,
                            const char   *filename)
{
#ifdef HAVE_NS_WEB_BROWSER
    nsresult rv;

    nsCString cFile(filename);

    nsCOMPtr<nsILocalFile> destFile = do_CreateInstance("@mozilla.org/file/local;1");
    NS_ENSURE_TRUE(destFile, FALSE);

    destFile->InitWithNativePath(cFile);

    GString *path = g_string_new (filename);
    char *dot_pos = strchr (path->str, '.');
    if (dot_pos) {
        g_string_truncate (path, dot_pos - path->str);
    }
    g_string_append (path, " Files");

    nsCOMPtr<nsILocalFile> filesFolder;    
    filesFolder = do_CreateInstance ("@mozilla.org/file/local;1");
    filesFolder->InitWithNativePath (nsCString(path->str));

    g_string_free (path, TRUE);

	nsCOMPtr<nsIWebBrowser> webBrowser;
	gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(browser),
									getter_AddRefs(webBrowser));
	NS_ENSURE_TRUE(webBrowser, FALSE);

    nsCOMPtr<nsIDOMWindow> DOMWindow;
    webBrowser->GetContentDOMWindow(getter_AddRefs(DOMWindow));
	NS_ENSURE_TRUE(DOMWindow, FALSE);

    nsCOMPtr<nsIDOMDocument> DOMDocument;
    DOMWindow->GetDocument (getter_AddRefs(DOMDocument));
	NS_ENSURE_TRUE(DOMDocument, FALSE);

	nsCOMPtr<nsIWebBrowserPersist> webPersist = do_QueryInterface (webBrowser);
	NS_ENSURE_TRUE(webPersist, FALSE);

    rv = webPersist->SaveDocument(DOMDocument, destFile, filesFolder, nsnull, 0, 0);
    NS_ENSURE_SUCCESS(rv, FALSE);

    return TRUE;
#else
    return FALSE;
#endif
}

GType
sugar_browser_event_get_type(void)
{
    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {
        type = g_boxed_type_register_static("SugarBrowserEvent",
                            (GBoxedCopyFunc)sugar_browser_event_copy,
                            (GBoxedFreeFunc)sugar_browser_event_free);
    }

    return type;
}

SugarBrowserEvent *
sugar_browser_event_new(void)
{
    SugarBrowserEvent *event;

    event = g_new0(SugarBrowserEvent, 1);

    return event;
}

SugarBrowserEvent *
sugar_browser_event_copy(SugarBrowserEvent *event)
{
    SugarBrowserEvent *copy;

    g_return_val_if_fail(event != NULL, NULL);

    copy = g_new0(SugarBrowserEvent, 1);
    copy->button = event->button;
    copy->image_uri = g_strdup(event->image_uri);
    copy->image_name = g_strdup(event->image_name);

    return copy;
}

void
sugar_browser_event_free(SugarBrowserEvent *event)
{
    g_return_if_fail(event != NULL);

    if (event->image_uri) {
        g_free(event->image_uri);
    }
    if (event->image_name) {
        g_free(event->image_name);
    }

    g_free(event);
}

GType
sugar_browser_metadata_get_type(void)
{
    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {
        type = g_boxed_type_register_static("SugarBrowserMetadata",
                            (GBoxedCopyFunc)sugar_browser_metadata_copy,
                            (GBoxedFreeFunc)sugar_browser_metadata_free);
    }

    return type;
}

SugarBrowserMetadata *
sugar_browser_metadata_new(void)
{
    SugarBrowserMetadata *metadata;

    metadata = g_new0(SugarBrowserMetadata, 1);

    return metadata;
}

SugarBrowserMetadata *
sugar_browser_metadata_copy(SugarBrowserMetadata *metadata)
{
    SugarBrowserMetadata *copy;

    g_return_val_if_fail(metadata != NULL, NULL);

    copy = g_new0(SugarBrowserMetadata, 1);
    copy->filename = g_strdup(metadata->filename);

    return copy;
}

void
sugar_browser_metadata_free(SugarBrowserMetadata *metadata)
{
    g_return_if_fail(metadata != NULL);

    if (metadata->filename) {
        g_free(metadata->filename);
    }

    g_free(metadata);
}