packages: Separate out most of the remaining packages into recipes

Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>

19 files changed, 3467 insertions, 0 deletions

diff --git a/meta-moblin/packages/clutter/clutter-mozembed.inc b/meta-moblin/packages/clutter/clutter-mozembed.inc
new file mode 100644
index 0000000000..72c9412d04
--- /dev/null
+++ b/meta-moblin/packages/clutter/clutter-mozembed.inc
@@ -0,0 +1,14 @@
+DESCRIPTION = "Clutter Mozilla Embedded"
+HOMEPAGE = "http://www.clutter-project.org/"
+LICENSE = "LGPL"
+
+DEPENDS = "mozilla-headless mozilla-headless-services clutter-1.0"
+
+FILESPATH = "${FILE_DIRNAME}/clutter-mozembed"
+
+FILES_${PN} =+ "${datadir}/cluttermozembed/chrome/"
+
+EXTRA_OECONF = "--enable-plugins"
+
+inherit autotools pkgconfig gtk-doc
+
diff --git a/meta-moblin/packages/clutter/clutter-mozembed_git.bb b/meta-moblin/packages/clutter/clutter-mozembed_git.bb
new file mode 100644
index 0000000000..e2da2d6a7d
--- /dev/null
+++ b/meta-moblin/packages/clutter/clutter-mozembed_git.bb
@@ -0,0 +1,14 @@
+require clutter-mozembed.inc
+
+PV = "0.8.0+git${SRCPV}"
+PR = "r7"
+
+SRC_URI = "git://git.clutter-project.org/clutter-mozembed.git;protocol=git \
+           file://link-with-g++-da7632f3e2c8d1a70ab01cc7adb63760d8718b41.patch;patch=1;rev=da7632f3e2c8d1a70ab01cc7adb63760d8718b41 \
+           file://link-with-g++.patch;patch=1;notrev=da7632f3e2c8d1a70ab01cc7adb63760d8718b41"
+S = "${WORKDIR}/git"
+
+do_configure_prepend () {
+	touch ${S}/clutter-mozembed/dummy.cpp
+	touch ${S}/clutter-mozembed/dummy2.cpp
+}
diff --git a/meta-moblin/packages/libidl/libidl_0.8.12.bb b/meta-moblin/packages/libidl/libidl_0.8.12.bb
new file mode 100644
index 0000000000..9cc9ea2ed8
--- /dev/null
+++ b/meta-moblin/packages/libidl/libidl_0.8.12.bb
@@ -0,0 +1,16 @@
+LICENSE = "LGPL"
+DESCRIPTION = "Library for parsing CORBA IDL files"
+SECTION = "gnome/libs"
+DEPENDS = "glib-2.0 flex"
+PR = "r4"
+
+SRC_URI = "http://ftp.gnome.org/pub/GNOME/sources/libIDL/0.8/libIDL-${PV}.tar.bz2"
+S = "${WORKDIR}/libIDL-${PV}"
+
+BINCONFIG_GLOB = "*-config-2"
+inherit autotools pkgconfig binconfig
+
+FILES_${PN} = "${libdir}/*.so.*"
+FILES_${PN}-dev += " ${bindir}" 
+
+BBCLASSEXTEND = "native"
diff --git a/meta-moblin/packages/mozilla-headless/mozilla-headless-services/confighack.patch b/meta-moblin/packages/mozilla-headless/mozilla-headless-services/confighack.patch
new file mode 100644
index 0000000000..dcfe11e0ff
--- /dev/null
+++ b/meta-moblin/packages/mozilla-headless/mozilla-headless-services/confighack.patch
@@ -0,0 +1,13 @@
+Index: places-glib/configure.ac
+===================================================================
+--- places-glib.orig/configure.ac	2009-04-17 10:29:15.000000000 +0100
++++ places-glib/configure.ac	2009-04-17 10:29:44.000000000 +0100
+@@ -99,6 +99,8 @@
+ PKG_CHECK_MODULES(GLIB, [glib-2.0])
+ PKG_CHECK_MODULES(DBUS, [dbus-glib-1])
+ 
++XUL_LIBS="$XUL_LIBS -lmozjs"
++
+ MOZHOME=`${PKG_CONFIG} --variable=prefix mozilla-headless`"/lib/xulrunner-"`${PKG_CONFIG} --modversion mozilla-headless`
+ AC_SUBST([MOZHOME])
+ 
diff --git a/meta-moblin/packages/mozilla-headless/mozilla-headless-services_git.bb b/meta-moblin/packages/mozilla-headless/mozilla-headless-services_git.bb
new file mode 100644
index 0000000000..14d64fa8c3
--- /dev/null
+++ b/meta-moblin/packages/mozilla-headless/mozilla-headless-services_git.bb
@@ -0,0 +1,14 @@
+SRC_URI = "git://git.moblin.org/mozilla-headless-services.git;protocol=git \
+           file://confighack.patch;patch=1"
+PV = "0.1+git${SRCPV}"
+PR = "r1"
+
+DEPENDS = "glib-2.0 dbus mozilla-headless json-glib"
+
+EXTRA_OECONF = "--enable-gnome-proxy"
+
+S = "${WORKDIR}/git"
+
+FILES_${PN} += "${datadir}/dbus-1/services"
+
+inherit autotools
diff --git a/meta-moblin/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch b/meta-moblin/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch
new file mode 100644
index 0000000000..db9e147990
--- /dev/null
+++ b/meta-moblin/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch
@@ -0,0 +1,1478 @@
+From fb41f028badb4dfddfc47fb2a1a68c1aa90dcef5 Mon Sep 17 00:00:00 2001
+From: Robert Bragg <robert@linux.intel.com>
+Date: Fri, 8 May 2009 13:57:22 +0100
+Subject: [PATCH] Adds initial Gtk clipboard support to moz-headless
+
+If build with MOZ_X11 enabled then this now builds the clipboard code taken
+from the gtk2 backend.  This doesn't provide any embedding API yet to expose
+the clipboard.
+---
+ widget/src/headless/Makefile.in         |    6 +
+ widget/src/headless/nsClipboard.cpp     |  948 +++++++++++++++++++++++++++++++
+ widget/src/headless/nsClipboard.h       |   93 +++
+ widget/src/headless/nsIImageToPixbuf.h  |   62 ++
+ widget/src/headless/nsImageToPixbuf.cpp |  196 +++++++
+ widget/src/headless/nsImageToPixbuf.h   |   71 +++
+ widget/src/headless/nsWidgetFactory.cpp |   18 +
+ 7 files changed, 1394 insertions(+), 0 deletions(-)
+ create mode 100644 widget/src/headless/nsClipboard.cpp
+ create mode 100644 widget/src/headless/nsClipboard.h
+ create mode 100644 widget/src/headless/nsIImageToPixbuf.h
+ create mode 100644 widget/src/headless/nsImageToPixbuf.cpp
+ create mode 100644 widget/src/headless/nsImageToPixbuf.h
+
+Index: offscreen/widget/src/headless/Makefile.in
+===================================================================
+--- offscreen.orig/widget/src/headless/Makefile.in	2009-05-16 18:23:25.000000000 +0100
++++ offscreen/widget/src/headless/Makefile.in	2009-06-12 14:14:05.000000000 +0100
+@@ -95,6 +95,12 @@
+ 		nsScreenManagerHeadless.cpp \
+ 		$(NULL)
+ 
++ifdef MOZ_X11
++CPPSRCS +=      nsClipboard.cpp \
++		nsImageToPixbuf.cpp \
++                $(NULL)
++endif
++
+ # build our subdirs, too
+ SHARED_LIBRARY_LIBS = ../xpwidgets/libxpwidgets_s.a
+ 
+Index: offscreen/widget/src/headless/nsClipboard.cpp
+===================================================================
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ offscreen/widget/src/headless/nsClipboard.cpp	2009-06-12 14:14:05.000000000 +0100
+@@ -0,0 +1,948 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
++/* vim:expandtab:shiftwidth=4:tabstop=4:
++ */
++/* ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is Christopher Blizzard
++ * <blizzard@mozilla.org>.  Portions created by the Initial Developer
++ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++
++#include "nsClipboard.h"
++#include "nsSupportsPrimitives.h"
++#include "nsString.h"
++#include "nsReadableUtils.h"
++#include "nsXPIDLString.h"
++#include "nsPrimitiveHelpers.h"
++#include "nsICharsetConverterManager.h"
++#include "nsIServiceManager.h"
++#include "nsIImage.h"
++#include "nsImageToPixbuf.h"
++#include "nsStringStream.h"
++
++#include <gtk/gtk.h>
++
++// For manipulation of the X event queue
++#include <X11/Xlib.h>
++#include <gdk/gdkx.h>
++#include <sys/time.h>
++#include <sys/types.h>
++#include <unistd.h>
++
++#ifdef POLL_WITH_XCONNECTIONNUMBER
++#include <poll.h>
++#endif
++
++// Callback when someone asks us for the selection
++void
++invisible_selection_get_cb (GtkWidget          *aWidget,
++                            GtkSelectionData   *aSelectionData,
++                            guint               aTime,
++                            guint               aInfo,
++                            nsClipboard        *aClipboard);
++
++gboolean
++selection_clear_event_cb   (GtkWidget          *aWidget,
++                            GdkEventSelection  *aEvent,
++                            nsClipboard        *aClipboard);
++
++static void
++ConvertHTMLtoUCS2          (guchar             *data,
++                            PRInt32             dataLength,
++                            PRUnichar         **unicodeData,
++                            PRInt32            &outUnicodeLen);
++
++static void
++GetHTMLCharset             (guchar * data, PRInt32 dataLength, nsCString& str);
++
++
++// Our own versions of gtk_clipboard_wait_for_contents and
++// gtk_clipboard_wait_for_text, which don't run the event loop while
++// waiting for the data.  This prevents a lot of problems related to
++// dispatching events at unexpected times.
++
++static GtkSelectionData *
++wait_for_contents          (GtkClipboard *clipboard, GdkAtom target);
++
++static gchar *
++wait_for_text              (GtkClipboard *clipboard);
++
++static Bool
++checkEventProc(Display *display, XEvent *event, XPointer arg);
++
++struct retrieval_context
++{
++    PRBool   completed;
++    void    *data;
++
++    retrieval_context() : completed(PR_FALSE), data(nsnull) { }
++};
++
++static void
++wait_for_retrieval(GtkClipboard *clipboard, retrieval_context *transferData);
++
++static void
++clipboard_contents_received(GtkClipboard     *clipboard,
++                            GtkSelectionData *selection_data,
++                            gpointer          data);
++
++static void
++clipboard_text_received(GtkClipboard *clipboard,
++                        const gchar  *text,
++                        gpointer      data);
++
++nsClipboard::nsClipboard()
++{
++    mWidget = nsnull;
++}
++
++nsClipboard::~nsClipboard()
++{
++    if (mWidget)
++        gtk_widget_destroy(mWidget);
++}
++
++NS_IMPL_ISUPPORTS1(nsClipboard, nsIClipboard)
++
++nsresult
++nsClipboard::Init(void)
++{
++    mWidget = gtk_invisible_new();
++    if (!mWidget)
++        return NS_ERROR_FAILURE;
++
++    g_signal_connect(G_OBJECT(mWidget), "selection_get",
++                     G_CALLBACK(invisible_selection_get_cb), this);
++
++    g_signal_connect(G_OBJECT(mWidget), "selection_clear_event",
++                     G_CALLBACK(selection_clear_event_cb), this);
++
++    // XXX make sure to set up the selection_clear event
++
++    return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::SetData(nsITransferable *aTransferable,
++                     nsIClipboardOwner *aOwner, PRInt32 aWhichClipboard)
++{
++    // See if we can short cut
++    if ((aWhichClipboard == kGlobalClipboard &&
++         aTransferable == mGlobalTransferable.get() &&
++         aOwner == mGlobalOwner.get()) ||
++        (aWhichClipboard == kSelectionClipboard &&
++         aTransferable == mSelectionTransferable.get() &&
++         aOwner == mSelectionOwner.get())) {
++        return NS_OK;
++    }
++
++    nsresult rv;
++    if (!mPrivacyHandler) {
++        rv = NS_NewClipboardPrivacyHandler(getter_AddRefs(mPrivacyHandler));
++        NS_ENSURE_SUCCESS(rv, rv);
++    }
++    rv = mPrivacyHandler->PrepareDataForClipboard(aTransferable);
++    NS_ENSURE_SUCCESS(rv, rv);
++
++    // Clear out the clipboard in order to set the new data
++    EmptyClipboard(aWhichClipboard);
++
++    if (aWhichClipboard == kSelectionClipboard) {
++        mSelectionOwner = aOwner;
++        mSelectionTransferable = aTransferable;
++    }
++    else {
++        mGlobalOwner = aOwner;
++        mGlobalTransferable = aTransferable;
++    }
++
++    // Which selection are we about to claim, CLIPBOARD or PRIMARY?
++    GdkAtom selectionAtom = GetSelectionAtom(aWhichClipboard);
++
++    // Make ourselves the owner.  If we fail to, return.
++    if (!gtk_selection_owner_set(mWidget, selectionAtom, GDK_CURRENT_TIME))
++        return NS_ERROR_FAILURE;
++
++    // Clear the old selection target list.
++    gtk_selection_clear_targets(mWidget, selectionAtom);
++
++    // Get the types of supported flavors
++    nsCOMPtr<nsISupportsArray> flavors;
++
++    rv = aTransferable->FlavorsTransferableCanExport(getter_AddRefs(flavors));
++    if (!flavors || NS_FAILED(rv))
++        return NS_ERROR_FAILURE;
++
++    // Add all the flavors to this widget's supported type.
++    PRUint32 count;
++    flavors->Count(&count);
++    for (PRUint32 i=0; i < count; i++) {
++        nsCOMPtr<nsISupports> tastesLike;
++        flavors->GetElementAt(i, getter_AddRefs(tastesLike));
++        nsCOMPtr<nsISupportsCString> flavor = do_QueryInterface(tastesLike);
++
++        if (flavor) {
++            nsXPIDLCString flavorStr;
++            flavor->ToString(getter_Copies(flavorStr));
++
++            // special case text/unicode since we can handle all of
++            // the string types
++            if (!strcmp(flavorStr, kUnicodeMime)) {
++                AddTarget(gdk_atom_intern("UTF8_STRING", FALSE),
++                          selectionAtom);
++                AddTarget(gdk_atom_intern("COMPOUND_TEXT", FALSE),
++                          selectionAtom);
++                AddTarget(gdk_atom_intern("TEXT", FALSE), selectionAtom);
++                AddTarget(GDK_SELECTION_TYPE_STRING, selectionAtom);
++                // next loop iteration
++                continue;
++            }
++
++            // very special case for this one. since our selection mechanism doesn't work for images,
++            // we must use GTK's clipboard utility functions
++            if (!strcmp(flavorStr, kNativeImageMime) || !strcmp(flavorStr, kPNGImageMime) ||
++                !strcmp(flavorStr, kJPEGImageMime) || !strcmp(flavorStr, kGIFImageMime)) {
++                nsCOMPtr<nsISupports> item;
++                PRUint32 len;
++                rv = aTransferable->GetTransferData(flavorStr, getter_AddRefs(item), &len);
++                nsCOMPtr<nsISupportsInterfacePointer> ptrPrimitive(do_QueryInterface(item));
++                if (!ptrPrimitive)
++                    continue;
++
++                nsCOMPtr<nsISupports> primitiveData;
++                ptrPrimitive->GetData(getter_AddRefs(primitiveData));
++                nsCOMPtr<nsIImage> image(do_QueryInterface(primitiveData));
++                if (!image) // Not getting an image for an image mime type!?
++                    continue;
++
++                if (NS_FAILED(image->LockImagePixels(PR_FALSE)))
++                    continue;
++                GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
++                if (!pixbuf) {
++                    image->UnlockImagePixels(PR_FALSE);
++                    continue;
++                }
++
++                GtkClipboard *aClipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
++                gtk_clipboard_set_image(aClipboard, pixbuf);
++                g_object_unref(pixbuf);
++                image->UnlockImagePixels(PR_FALSE);
++                continue;
++            }
++
++            // Add this to our list of valid targets
++            GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
++            AddTarget(atom, selectionAtom);
++        }
++    }
++
++    return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::GetData(nsITransferable *aTransferable, PRInt32 aWhichClipboard)
++{
++    if (!aTransferable)
++        return NS_ERROR_FAILURE;
++
++    GtkClipboard *clipboard;
++    clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
++
++    guchar        *data = NULL;
++    gint           length = 0;
++    PRBool         foundData = PR_FALSE;
++    nsCAutoString  foundFlavor;
++
++    // Get a list of flavors this transferable can import
++    nsCOMPtr<nsISupportsArray> flavors;
++    nsresult rv;
++    rv = aTransferable->FlavorsTransferableCanImport(getter_AddRefs(flavors));
++    if (!flavors || NS_FAILED(rv))
++        return NS_ERROR_FAILURE;
++
++    PRUint32 count;
++    flavors->Count(&count);
++    for (PRUint32 i=0; i < count; i++) {
++        nsCOMPtr<nsISupports> genericFlavor;
++        flavors->GetElementAt(i, getter_AddRefs(genericFlavor));
++
++        nsCOMPtr<nsISupportsCString> currentFlavor;
++        currentFlavor = do_QueryInterface(genericFlavor);
++
++        if (currentFlavor) {
++            nsXPIDLCString flavorStr;
++            currentFlavor->ToString(getter_Copies(flavorStr));
++
++            // Special case text/unicode since we can convert any
++            // string into text/unicode
++            if (!strcmp(flavorStr, kUnicodeMime)) {
++                gchar* new_text = wait_for_text(clipboard);
++                if (new_text) {
++                    // Convert utf-8 into our unicode format.
++                    NS_ConvertUTF8toUTF16 ucs2string(new_text);
++                    data = (guchar *)ToNewUnicode(ucs2string);
++                    length = ucs2string.Length() * 2;
++                    g_free(new_text);
++                    foundData = PR_TRUE;
++                    foundFlavor = kUnicodeMime;
++                    break;
++                }
++                // If the type was text/unicode and we couldn't get
++                // text off the clipboard, run the next loop
++                // iteration.
++                continue;
++            }
++
++            // For images, we must wrap the data in an nsIInputStream then return instead of break,
++            // because that code below won't help us.
++            if (!strcmp(flavorStr, kJPEGImageMime) || !strcmp(flavorStr, kPNGImageMime) || !strcmp(flavorStr, kGIFImageMime)) {
++                GdkAtom atom;
++                if (!strcmp(flavorStr, kJPEGImageMime)) // This is image/jpg, but X only understands image/jpeg
++                    atom = gdk_atom_intern("image/jpeg", FALSE);
++                else
++                    atom = gdk_atom_intern(flavorStr, FALSE);
++
++                GtkSelectionData *selectionData = wait_for_contents(clipboard, atom);
++                if (!selectionData)
++                    continue;
++
++                nsCOMPtr<nsIInputStream> byteStream;
++                NS_NewByteInputStream(getter_AddRefs(byteStream), (const char*)selectionData->data,
++                                      selectionData->length, NS_ASSIGNMENT_COPY);
++                aTransferable->SetTransferData(flavorStr, byteStream, sizeof(nsIInputStream*));
++                gtk_selection_data_free(selectionData);
++                return NS_OK;
++            }
++
++            // Get the atom for this type and try to request it off
++            // the clipboard.
++            GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
++            GtkSelectionData *selectionData;
++            selectionData = wait_for_contents(clipboard, atom);
++            if (selectionData) {
++                length = selectionData->length;
++                // Special case text/html since we can convert into UCS2
++                if (!strcmp(flavorStr, kHTMLMime)) {
++                    PRUnichar* htmlBody= nsnull;
++                    PRInt32 htmlBodyLen = 0;
++                    // Convert text/html into our unicode format
++                    ConvertHTMLtoUCS2((guchar *)selectionData->data, length,
++                                      &htmlBody, htmlBodyLen);
++                    if (!htmlBodyLen)
++                        break;
++                    data = (guchar *)htmlBody;
++                    length = htmlBodyLen * 2;
++                } else {
++                    data = (guchar *)nsMemory::Alloc(length);
++                    if (!data)
++                        break;
++                    memcpy(data, selectionData->data, length);
++                }
++                foundData = PR_TRUE;
++                foundFlavor = flavorStr;
++                break;
++            }
++        }
++    }
++
++    if (foundData) {
++        nsCOMPtr<nsISupports> wrapper;
++        nsPrimitiveHelpers::CreatePrimitiveForData(foundFlavor.get(),
++                                                   data, length,
++                                                   getter_AddRefs(wrapper));
++        aTransferable->SetTransferData(foundFlavor.get(),
++                                       wrapper, length);
++    }
++
++    if (data)
++        nsMemory::Free(data);
++
++    return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::EmptyClipboard(PRInt32 aWhichClipboard)
++{
++    if (aWhichClipboard == kSelectionClipboard) {
++        if (mSelectionOwner) {
++            mSelectionOwner->LosingOwnership(mSelectionTransferable);
++            mSelectionOwner = nsnull;
++        }
++        mSelectionTransferable = nsnull;
++    }
++    else {
++        if (mGlobalOwner) {
++            mGlobalOwner->LosingOwnership(mGlobalTransferable);
++            mGlobalOwner = nsnull;
++        }
++        mGlobalTransferable = nsnull;
++    }
++
++    return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::HasDataMatchingFlavors(const char** aFlavorList, PRUint32 aLength,
++                                    PRInt32 aWhichClipboard, PRBool *_retval)
++{
++    if (!aFlavorList || !_retval)
++        return NS_ERROR_NULL_POINTER;
++
++    *_retval = PR_FALSE;
++
++    GtkSelectionData *selection_data =
++        GetTargets(GetSelectionAtom(aWhichClipboard));
++    if (!selection_data)
++        return NS_OK;
++
++    gint n_targets = 0;
++    GdkAtom *targets = NULL;
++
++    if (!gtk_selection_data_get_targets(selection_data, 
++                                        &targets, &n_targets) ||
++        !n_targets)
++        return NS_OK;
++
++    // Walk through the provided types and try to match it to a
++    // provided type.
++    for (PRUint32 i = 0; i < aLength && !*_retval; i++) {
++        // We special case text/unicode here.
++        if (!strcmp(aFlavorList[i], kUnicodeMime) && 
++            gtk_selection_data_targets_include_text(selection_data)) {
++            *_retval = PR_TRUE;
++            break;
++        }
++
++        for (PRInt32 j = 0; j < n_targets; j++) {
++            gchar *atom_name = gdk_atom_name(targets[j]);
++            if (!strcmp(atom_name, aFlavorList[i]))
++                *_retval = PR_TRUE;
++
++            // X clipboard wants image/jpeg, not image/jpg
++            if (!strcmp(aFlavorList[i], kJPEGImageMime) && !strcmp(atom_name, "image/jpeg"))
++                *_retval = PR_TRUE;
++
++            g_free(atom_name);
++
++            if (*_retval)
++                break;
++        }
++    }
++    gtk_selection_data_free(selection_data);
++    g_free(targets);
++
++    return NS_OK;
++}
++
++NS_IMETHODIMP
++nsClipboard::SupportsSelectionClipboard(PRBool *_retval)
++{
++    *_retval = PR_TRUE; // yeah, unix supports the selection clipboard
++    return NS_OK;
++}
++
++/* static */
++GdkAtom
++nsClipboard::GetSelectionAtom(PRInt32 aWhichClipboard)
++{
++    if (aWhichClipboard == kGlobalClipboard)
++        return GDK_SELECTION_CLIPBOARD;
++
++    return GDK_SELECTION_PRIMARY;
++}
++
++/* static */
++GtkSelectionData *
++nsClipboard::GetTargets(GdkAtom aWhichClipboard)
++{
++    GtkClipboard *clipboard = gtk_clipboard_get(aWhichClipboard);
++    return wait_for_contents(clipboard, gdk_atom_intern("TARGETS", FALSE));
++}
++
++nsITransferable *
++nsClipboard::GetTransferable(PRInt32 aWhichClipboard)
++{
++    nsITransferable *retval;
++
++    if (aWhichClipboard == kSelectionClipboard)
++        retval = mSelectionTransferable.get();
++    else
++        retval = mGlobalTransferable.get();
++        
++    return retval;
++}
++
++void
++nsClipboard::AddTarget(GdkAtom aName, GdkAtom aClipboard)
++{
++    gtk_selection_add_target(mWidget, aClipboard, aName, 0);
++}
++
++void
++nsClipboard::SelectionGetEvent (GtkWidget        *aWidget,
++                                GtkSelectionData *aSelectionData,
++                                guint             aTime)
++{
++    // Someone has asked us to hand them something.  The first thing
++    // that we want to do is see if that something includes text.  If
++    // it does, try to give it text/unicode after converting it to
++    // utf-8.
++
++    PRInt32 whichClipboard;
++
++    // which clipboard?
++    if (aSelectionData->selection == GDK_SELECTION_PRIMARY)
++        whichClipboard = kSelectionClipboard;
++    else if (aSelectionData->selection == GDK_SELECTION_CLIPBOARD)
++        whichClipboard = kGlobalClipboard;
++    else
++        return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
++
++    nsCOMPtr<nsITransferable> trans = GetTransferable(whichClipboard);
++    
++    nsresult rv;
++    nsCOMPtr<nsISupports> item;
++    PRUint32 len;
++
++    // Check to see if the selection data includes any of the string
++    // types that we support.
++    if (aSelectionData->target == gdk_atom_intern ("STRING", FALSE) ||
++        aSelectionData->target == gdk_atom_intern ("TEXT", FALSE) ||
++        aSelectionData->target == gdk_atom_intern ("COMPOUND_TEXT", FALSE) ||
++        aSelectionData->target == gdk_atom_intern ("UTF8_STRING", FALSE)) {
++        // Try to convert our internal type into a text string.  Get
++        // the transferable for this clipboard and try to get the
++        // text/unicode type for it.
++        rv = trans->GetTransferData("text/unicode", getter_AddRefs(item),
++                                    &len);
++        if (!item || NS_FAILED(rv))
++            return;
++        
++        nsCOMPtr<nsISupportsString> wideString;
++        wideString = do_QueryInterface(item);
++        if (!wideString)
++            return;
++
++        nsAutoString ucs2string;
++        wideString->GetData(ucs2string);
++        char *utf8string = ToNewUTF8String(ucs2string);
++        if (!utf8string)
++            return;
++        
++        gtk_selection_data_set_text (aSelectionData, utf8string,
++                                     strlen(utf8string));
++
++        nsMemory::Free(utf8string);
++        return;
++    }
++
++    // Try to match up the selection data target to something our
++    // transferable provides.
++    gchar *target_name = gdk_atom_name(aSelectionData->target);
++    if (!target_name)
++        return;
++
++    rv = trans->GetTransferData(target_name, getter_AddRefs(item), &len);
++    // nothing found?
++    if (!item || NS_FAILED(rv)) {
++        g_free(target_name);
++        return;
++    }
++
++    void *primitive_data = nsnull;
++    nsPrimitiveHelpers::CreateDataFromPrimitive(target_name, item,
++                                                &primitive_data, len);
++
++    if (primitive_data) {
++        // Check to see if the selection data is text/html
++        if (aSelectionData->target == gdk_atom_intern (kHTMLMime, FALSE)) {
++            /*
++             * "text/html" can be encoded UCS2. It is recommended that
++             * documents transmitted as UCS2 always begin with a ZERO-WIDTH
++             * NON-BREAKING SPACE character (hexadecimal FEFF, also called
++             * Byte Order Mark (BOM)). Adding BOM can help other app to
++             * detect mozilla use UCS2 encoding when copy-paste.
++             */
++            guchar *buffer = (guchar *)
++                    nsMemory::Alloc((len * sizeof(guchar)) + sizeof(PRUnichar));
++            if (!buffer)
++                return;
++            PRUnichar prefix = 0xFEFF;
++            memcpy(buffer, &prefix, sizeof(prefix));
++            memcpy(buffer + sizeof(prefix), primitive_data, len);
++            nsMemory::Free((guchar *)primitive_data);
++            primitive_data = (guchar *)buffer;
++            len += sizeof(prefix);
++        }
++  
++        gtk_selection_data_set(aSelectionData, aSelectionData->target,
++                               8, /* 8 bits in a unit */
++                               (const guchar *)primitive_data, len);
++        nsMemory::Free(primitive_data);
++    }
++
++    g_free(target_name);
++                           
++}
++
++void
++nsClipboard::SelectionClearEvent (GtkWidget         *aWidget,
++                                  GdkEventSelection *aEvent)
++{
++    PRInt32 whichClipboard;
++
++    // which clipboard?
++    if (aEvent->selection == GDK_SELECTION_PRIMARY)
++        whichClipboard = kSelectionClipboard;
++    else if (aEvent->selection == GDK_SELECTION_CLIPBOARD)
++        whichClipboard = kGlobalClipboard;
++    else
++        return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
++
++    EmptyClipboard(whichClipboard);
++}
++
++void
++invisible_selection_get_cb (GtkWidget          *aWidget,
++                            GtkSelectionData   *aSelectionData,
++                            guint               aTime,
++                            guint               aInfo,
++                            nsClipboard        *aClipboard)
++{
++    aClipboard->SelectionGetEvent(aWidget, aSelectionData, aTime);
++}
++
++gboolean
++selection_clear_event_cb   (GtkWidget          *aWidget,
++                            GdkEventSelection  *aEvent,
++                            nsClipboard        *aClipboard)