summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRichard Purdie <rpurdie@linux.intel.com>2009-05-20 01:22:17 +0100
committerRichard Purdie <rpurdie@linux.intel.com>2009-05-20 01:22:17 +0100
commit6c5d81946aac4f94ca42fdc02542420cb38ed756 (patch)
tree753a0196a5d55d453929286cb9256a13d6774d7f
parent25185d5bb2cc100c606d332482ba2243f0aab3c9 (diff)
downloadpoky-6c5d81946aac4f94ca42fdc02542420cb38ed756.tar.gz
mozilla-headless: Hardcode compiler options for now
Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>
Diffstat
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch1486
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/arm/jsautocfg.h54
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/i386/jsautocfg.h39
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/i486/jsautocfg.h39
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/i586/jsautocfg.h39
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/i686/jsautocfg.h39
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/mozilla-jemalloc.patch24
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless/powerpc/jsautocfg.h54
-rw-r--r--meta/packages/mozilla-headless/mozilla-headless_hg.bb17
9 files changed, 1532 insertions, 259 deletions
diff --git a/meta/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch b/meta/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch
new file mode 100644
index 0000000000..b3972e78f7
--- /dev/null
+++ b/meta/packages/mozilla-headless/mozilla-headless/0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch
@@ -0,0 +1,1486 @@
1From fb41f028badb4dfddfc47fb2a1a68c1aa90dcef5 Mon Sep 17 00:00:00 2001
2From: Robert Bragg <robert@linux.intel.com>
3Date: Fri, 8 May 2009 13:57:22 +0100
4Subject: [PATCH] Adds initial Gtk clipboard support to moz-headless
5
6If build with MOZ_X11 enabled then this now builds the clipboard code taken
7from the gtk2 backend. This doesn't provide any embedding API yet to expose
8the clipboard.
9---
10 widget/src/headless/Makefile.in | 6 +
11 widget/src/headless/nsClipboard.cpp | 948 +++++++++++++++++++++++++++++++
12 widget/src/headless/nsClipboard.h | 93 +++
13 widget/src/headless/nsIImageToPixbuf.h | 62 ++
14 widget/src/headless/nsImageToPixbuf.cpp | 196 +++++++
15 widget/src/headless/nsImageToPixbuf.h | 71 +++
16 widget/src/headless/nsWidgetFactory.cpp | 18 +
17 7 files changed, 1394 insertions(+), 0 deletions(-)
18 create mode 100644 widget/src/headless/nsClipboard.cpp
19 create mode 100644 widget/src/headless/nsClipboard.h
20 create mode 100644 widget/src/headless/nsIImageToPixbuf.h
21 create mode 100644 widget/src/headless/nsImageToPixbuf.cpp
22 create mode 100644 widget/src/headless/nsImageToPixbuf.h
23
24diff --git a/widget/src/headless/Makefile.in b/widget/src/headless/Makefile.in
25index c8727d9..cbdf900 100644
26--- a/widget/src/headless/Makefile.in
27+++ b/widget/src/headless/Makefile.in
28@@ -95,6 +95,12 @@ CPPSRCS = \
29 nsScreenManagerHeadless.cpp \
30 $(NULL)
31
32+ifdef MOZ_X11
33+CPPSRCS += nsClipboard.cpp \
34+ nsImageToPixbuf.cpp \
35+ $(NULL)
36+endif
37+
38 # build our subdirs, too
39 SHARED_LIBRARY_LIBS = ../xpwidgets/libxpwidgets_s.a
40
41diff --git a/widget/src/headless/nsClipboard.cpp b/widget/src/headless/nsClipboard.cpp
42new file mode 100644
43index 0000000..72a37fc
44--- /dev/null
45+++ b/widget/src/headless/nsClipboard.cpp
46@@ -0,0 +1,948 @@
47+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
48+/* vim:expandtab:shiftwidth=4:tabstop=4:
49+ */
50+/* ***** BEGIN LICENSE BLOCK *****
51+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
52+ *
53+ * The contents of this file are subject to the Mozilla Public License Version
54+ * 1.1 (the "License"); you may not use this file except in compliance with
55+ * the License. You may obtain a copy of the License at
56+ * http://www.mozilla.org/MPL/
57+ *
58+ * Software distributed under the License is distributed on an "AS IS" basis,
59+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
60+ * for the specific language governing rights and limitations under the
61+ * License.
62+ *
63+ * The Original Code is mozilla.org code.
64+ *
65+ * The Initial Developer of the Original Code is Christopher Blizzard
66+ * <blizzard@mozilla.org>. Portions created by the Initial Developer
67+ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
68+ *
69+ * Contributor(s):
70+ *
71+ * Alternatively, the contents of this file may be used under the terms of
72+ * either the GNU General Public License Version 2 or later (the "GPL"), or
73+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
74+ * in which case the provisions of the GPL or the LGPL are applicable instead
75+ * of those above. If you wish to allow use of your version of this file only
76+ * under the terms of either the GPL or the LGPL, and not to allow others to
77+ * use your version of this file under the terms of the MPL, indicate your
78+ * decision by deleting the provisions above and replace them with the notice
79+ * and other provisions required by the GPL or the LGPL. If you do not delete
80+ * the provisions above, a recipient may use your version of this file under
81+ * the terms of any one of the MPL, the GPL or the LGPL.
82+ *
83+ * ***** END LICENSE BLOCK ***** */
84+
85+#include "nsClipboard.h"
86+#include "nsSupportsPrimitives.h"
87+#include "nsString.h"
88+#include "nsReadableUtils.h"
89+#include "nsXPIDLString.h"
90+#include "nsPrimitiveHelpers.h"
91+#include "nsICharsetConverterManager.h"
92+#include "nsIServiceManager.h"
93+#include "nsIImage.h"
94+#include "nsImageToPixbuf.h"
95+#include "nsStringStream.h"
96+
97+#include <gtk/gtk.h>
98+
99+// For manipulation of the X event queue
100+#include <X11/Xlib.h>
101+#include <gdk/gdkx.h>
102+#include <sys/time.h>
103+#include <sys/types.h>
104+#include <unistd.h>
105+
106+#ifdef POLL_WITH_XCONNECTIONNUMBER
107+#include <poll.h>
108+#endif
109+
110+// Callback when someone asks us for the selection
111+void
112+invisible_selection_get_cb (GtkWidget *aWidget,
113+ GtkSelectionData *aSelectionData,
114+ guint aTime,
115+ guint aInfo,
116+ nsClipboard *aClipboard);
117+
118+gboolean
119+selection_clear_event_cb (GtkWidget *aWidget,
120+ GdkEventSelection *aEvent,
121+ nsClipboard *aClipboard);
122+
123+static void
124+ConvertHTMLtoUCS2 (guchar *data,
125+ PRInt32 dataLength,
126+ PRUnichar **unicodeData,
127+ PRInt32 &outUnicodeLen);
128+
129+static void
130+GetHTMLCharset (guchar * data, PRInt32 dataLength, nsCString& str);
131+
132+
133+// Our own versions of gtk_clipboard_wait_for_contents and
134+// gtk_clipboard_wait_for_text, which don't run the event loop while
135+// waiting for the data. This prevents a lot of problems related to
136+// dispatching events at unexpected times.
137+
138+static GtkSelectionData *
139+wait_for_contents (GtkClipboard *clipboard, GdkAtom target);
140+
141+static gchar *
142+wait_for_text (GtkClipboard *clipboard);
143+
144+static Bool
145+checkEventProc(Display *display, XEvent *event, XPointer arg);
146+
147+struct retrieval_context
148+{
149+ PRBool completed;
150+ void *data;
151+
152+ retrieval_context() : completed(PR_FALSE), data(nsnull) { }
153+};
154+
155+static void
156+wait_for_retrieval(GtkClipboard *clipboard, retrieval_context *transferData);
157+
158+static void
159+clipboard_contents_received(GtkClipboard *clipboard,
160+ GtkSelectionData *selection_data,
161+ gpointer data);
162+
163+static void
164+clipboard_text_received(GtkClipboard *clipboard,
165+ const gchar *text,
166+ gpointer data);
167+
168+nsClipboard::nsClipboard()
169+{
170+ mWidget = nsnull;
171+}
172+
173+nsClipboard::~nsClipboard()
174+{
175+ if (mWidget)
176+ gtk_widget_destroy(mWidget);
177+}
178+
179+NS_IMPL_ISUPPORTS1(nsClipboard, nsIClipboard)
180+
181+nsresult
182+nsClipboard::Init(void)
183+{
184+ mWidget = gtk_invisible_new();
185+ if (!mWidget)
186+ return NS_ERROR_FAILURE;
187+
188+ g_signal_connect(G_OBJECT(mWidget), "selection_get",
189+ G_CALLBACK(invisible_selection_get_cb), this);
190+
191+ g_signal_connect(G_OBJECT(mWidget), "selection_clear_event",
192+ G_CALLBACK(selection_clear_event_cb), this);
193+
194+ // XXX make sure to set up the selection_clear event
195+
196+ return NS_OK;
197+}
198+
199+NS_IMETHODIMP
200+nsClipboard::SetData(nsITransferable *aTransferable,
201+ nsIClipboardOwner *aOwner, PRInt32 aWhichClipboard)
202+{
203+ // See if we can short cut
204+ if ((aWhichClipboard == kGlobalClipboard &&
205+ aTransferable == mGlobalTransferable.get() &&
206+ aOwner == mGlobalOwner.get()) ||
207+ (aWhichClipboard == kSelectionClipboard &&
208+ aTransferable == mSelectionTransferable.get() &&
209+ aOwner == mSelectionOwner.get())) {
210+ return NS_OK;
211+ }
212+
213+ nsresult rv;
214+ if (!mPrivacyHandler) {
215+ rv = NS_NewClipboardPrivacyHandler(getter_AddRefs(mPrivacyHandler));
216+ NS_ENSURE_SUCCESS(rv, rv);
217+ }
218+ rv = mPrivacyHandler->PrepareDataForClipboard(aTransferable);
219+ NS_ENSURE_SUCCESS(rv, rv);
220+
221+ // Clear out the clipboard in order to set the new data
222+ EmptyClipboard(aWhichClipboard);
223+
224+ if (aWhichClipboard == kSelectionClipboard) {
225+ mSelectionOwner = aOwner;
226+ mSelectionTransferable = aTransferable;
227+ }
228+ else {
229+ mGlobalOwner = aOwner;
230+ mGlobalTransferable = aTransferable;
231+ }
232+
233+ // Which selection are we about to claim, CLIPBOARD or PRIMARY?
234+ GdkAtom selectionAtom = GetSelectionAtom(aWhichClipboard);
235+
236+ // Make ourselves the owner. If we fail to, return.
237+ if (!gtk_selection_owner_set(mWidget, selectionAtom, GDK_CURRENT_TIME))
238+ return NS_ERROR_FAILURE;
239+
240+ // Clear the old selection target list.
241+ gtk_selection_clear_targets(mWidget, selectionAtom);
242+
243+ // Get the types of supported flavors
244+ nsCOMPtr<nsISupportsArray> flavors;
245+
246+ rv = aTransferable->FlavorsTransferableCanExport(getter_AddRefs(flavors));
247+ if (!flavors || NS_FAILED(rv))
248+ return NS_ERROR_FAILURE;
249+
250+ // Add all the flavors to this widget's supported type.
251+ PRUint32 count;
252+ flavors->Count(&count);
253+ for (PRUint32 i=0; i < count; i++) {
254+ nsCOMPtr<nsISupports> tastesLike;
255+ flavors->GetElementAt(i, getter_AddRefs(tastesLike));
256+ nsCOMPtr<nsISupportsCString> flavor = do_QueryInterface(tastesLike);
257+
258+ if (flavor) {
259+ nsXPIDLCString flavorStr;
260+ flavor->ToString(getter_Copies(flavorStr));
261+
262+ // special case text/unicode since we can handle all of
263+ // the string types
264+ if (!strcmp(flavorStr, kUnicodeMime)) {
265+ AddTarget(gdk_atom_intern("UTF8_STRING", FALSE),
266+ selectionAtom);
267+ AddTarget(gdk_atom_intern("COMPOUND_TEXT", FALSE),
268+ selectionAtom);
269+ AddTarget(gdk_atom_intern("TEXT", FALSE), selectionAtom);
270+ AddTarget(GDK_SELECTION_TYPE_STRING, selectionAtom);
271+ // next loop iteration
272+ continue;
273+ }
274+
275+ // very special case for this one. since our selection mechanism doesn't work for images,
276+ // we must use GTK's clipboard utility functions
277+ if (!strcmp(flavorStr, kNativeImageMime) || !strcmp(flavorStr, kPNGImageMime) ||
278+ !strcmp(flavorStr, kJPEGImageMime) || !strcmp(flavorStr, kGIFImageMime)) {
279+ nsCOMPtr<nsISupports> item;
280+ PRUint32 len;
281+ rv = aTransferable->GetTransferData(flavorStr, getter_AddRefs(item), &len);
282+ nsCOMPtr<nsISupportsInterfacePointer> ptrPrimitive(do_QueryInterface(item));
283+ if (!ptrPrimitive)
284+ continue;
285+
286+ nsCOMPtr<nsISupports> primitiveData;
287+ ptrPrimitive->GetData(getter_AddRefs(primitiveData));
288+ nsCOMPtr<nsIImage> image(do_QueryInterface(primitiveData));
289+ if (!image) // Not getting an image for an image mime type!?
290+ continue;
291+
292+ if (NS_FAILED(image->LockImagePixels(PR_FALSE)))
293+ continue;
294+ GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
295+ if (!pixbuf) {
296+ image->UnlockImagePixels(PR_FALSE);
297+ continue;
298+ }
299+
300+ GtkClipboard *aClipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
301+ gtk_clipboard_set_image(aClipboard, pixbuf);
302+ g_object_unref(pixbuf);
303+ image->UnlockImagePixels(PR_FALSE);
304+ continue;
305+ }
306+
307+ // Add this to our list of valid targets
308+ GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
309+ AddTarget(atom, selectionAtom);
310+ }
311+ }
312+
313+ return NS_OK;
314+}
315+
316+NS_IMETHODIMP
317+nsClipboard::GetData(nsITransferable *aTransferable, PRInt32 aWhichClipboard)
318+{
319+ if (!aTransferable)
320+ return NS_ERROR_FAILURE;
321+
322+ GtkClipboard *clipboard;
323+ clipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
324+
325+ guchar *data = NULL;
326+ gint length = 0;
327+ PRBool foundData = PR_FALSE;
328+ nsCAutoString foundFlavor;
329+
330+ // Get a list of flavors this transferable can import
331+ nsCOMPtr<nsISupportsArray> flavors;
332+ nsresult rv;
333+ rv = aTransferable->FlavorsTransferableCanImport(getter_AddRefs(flavors));
334+ if (!flavors || NS_FAILED(rv))
335+ return NS_ERROR_FAILURE;
336+
337+ PRUint32 count;
338+ flavors->Count(&count);
339+ for (PRUint32 i=0; i < count; i++) {
340+ nsCOMPtr<nsISupports> genericFlavor;
341+ flavors->GetElementAt(i, getter_AddRefs(genericFlavor));
342+
343+ nsCOMPtr<nsISupportsCString> currentFlavor;
344+ currentFlavor = do_QueryInterface(genericFlavor);
345+
346+ if (currentFlavor) {
347+ nsXPIDLCString flavorStr;
348+ currentFlavor->ToString(getter_Copies(flavorStr));
349+
350+ // Special case text/unicode since we can convert any
351+ // string into text/unicode
352+ if (!strcmp(flavorStr, kUnicodeMime)) {
353+ gchar* new_text = wait_for_text(clipboard);
354+ if (new_text) {
355+ // Convert utf-8 into our unicode format.
356+ NS_ConvertUTF8toUTF16 ucs2string(new_text);
357+ data = (guchar *)ToNewUnicode(ucs2string);
358+ length = ucs2string.Length() * 2;
359+ g_free(new_text);
360+ foundData = PR_TRUE;
361+ foundFlavor = kUnicodeMime;
362+ break;
363+ }
364+ // If the type was text/unicode and we couldn't get
365+ // text off the clipboard, run the next loop
366+ // iteration.
367+ continue;
368+ }
369+
370+ // For images, we must wrap the data in an nsIInputStream then return instead of break,
371+ // because that code below won't help us.
372+ if (!strcmp(flavorStr, kJPEGImageMime) || !strcmp(flavorStr, kPNGImageMime) || !strcmp(flavorStr, kGIFImageMime)) {
373+ GdkAtom atom;
374+ if (!strcmp(flavorStr, kJPEGImageMime)) // This is image/jpg, but X only understands image/jpeg
375+ atom = gdk_atom_intern("image/jpeg", FALSE);
376+ else
377+ atom = gdk_atom_intern(flavorStr, FALSE);
378+
379+ GtkSelectionData *selectionData = wait_for_contents(clipboard, atom);
380+ if (!selectionData)
381+ continue;
382+
383+ nsCOMPtr<nsIInputStream> byteStream;
384+ NS_NewByteInputStream(getter_AddRefs(byteStream), (const char*)selectionData->data,
385+ selectionData->length, NS_ASSIGNMENT_COPY);
386+ aTransferable->SetTransferData(flavorStr, byteStream, sizeof(nsIInputStream*));
387+ gtk_selection_data_free(selectionData);
388+ return NS_OK;
389+ }
390+
391+ // Get the atom for this type and try to request it off
392+ // the clipboard.
393+ GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
394+ GtkSelectionData *selectionData;
395+ selectionData = wait_for_contents(clipboard, atom);
396+ if (selectionData) {
397+ length = selectionData->length;
398+ // Special case text/html since we can convert into UCS2
399+ if (!strcmp(flavorStr, kHTMLMime)) {
400+ PRUnichar* htmlBody= nsnull;
401+ PRInt32 htmlBodyLen = 0;
402+ // Convert text/html into our unicode format
403+ ConvertHTMLtoUCS2((guchar *)selectionData->data, length,
404+ &htmlBody, htmlBodyLen);
405+ if (!htmlBodyLen)
406+ break;
407+ data = (guchar *)htmlBody;
408+ length = htmlBodyLen * 2;
409+ } else {
410+ data = (guchar *)nsMemory::Alloc(length);
411+ if (!data)
412+ break;
413+ memcpy(data, selectionData->data, length);
414+ }
415+ foundData = PR_TRUE;
416+ foundFlavor = flavorStr;
417+ break;
418+ }
419+ }
420+ }
421+
422+ if (foundData) {
423+ nsCOMPtr<nsISupports> wrapper;
424+ nsPrimitiveHelpers::CreatePrimitiveForData(foundFlavor.get(),
425+ data, length,
426+ getter_AddRefs(wrapper));
427+ aTransferable->SetTransferData(foundFlavor.get(),
428+ wrapper, length);
429+ }
430+
431+ if (data)
432+ nsMemory::Free(data);
433+
434+ return NS_OK;
435+}
436+
437+NS_IMETHODIMP
438+nsClipboard::EmptyClipboard(PRInt32 aWhichClipboard)
439+{
440+ if (aWhichClipboard == kSelectionClipboard) {
441+ if (mSelectionOwner) {
442+ mSelectionOwner->LosingOwnership(mSelectionTransferable);
443+ mSelectionOwner = nsnull;
444+ }
445+ mSelectionTransferable = nsnull;
446+ }
447+ else {
448+ if (mGlobalOwner) {
449+ mGlobalOwner->LosingOwnership(mGlobalTransferable);
450+ mGlobalOwner = nsnull;
451+ }
452+ mGlobalTransferable = nsnull;
453+ }
454+
455+ return NS_OK;
456+}
457+
458+NS_IMETHODIMP
459+nsClipboard::HasDataMatchingFlavors(const char** aFlavorList, PRUint32 aLength,
460+ PRInt32 aWhichClipboard, PRBool *_retval)
461+{
462+ if (!aFlavorList || !_retval)
463+ return NS_ERROR_NULL_POINTER;
464+
465+ *_retval = PR_FALSE;
466+
467+ GtkSelectionData *selection_data =
468+ GetTargets(GetSelectionAtom(aWhichClipboard));
469+ if (!selection_data)
470+ return NS_OK;
471+
472+ gint n_targets = 0;
473+ GdkAtom *targets = NULL;
474+
475+ if (!gtk_selection_data_get_targets(selection_data,
476+ &targets, &n_targets) ||
477+ !n_targets)
478+ return NS_OK;
479+
480+ // Walk through the provided types and try to match it to a
481+ // provided type.
482+ for (PRUint32 i = 0; i < aLength && !*_retval; i++) {
483+ // We special case text/unicode here.
484+ if (!strcmp(aFlavorList[i], kUnicodeMime) &&
485+ gtk_selection_data_targets_include_text(selection_data)) {
486+ *_retval = PR_TRUE;
487+ break;
488+ }
489+
490+ for (PRInt32 j = 0; j < n_targets; j++) {
491+ gchar *atom_name = gdk_atom_name(targets[j]);
492+ if (!strcmp(atom_name, aFlavorList[i]))
493+ *_retval = PR_TRUE;
494+
495+ // X clipboard wants image/jpeg, not image/jpg
496+ if (!strcmp(aFlavorList[i], kJPEGImageMime) && !strcmp(atom_name, "image/jpeg"))
497+ *_retval = PR_TRUE;
498+
499+ g_free(atom_name);
500+
501+ if (*_retval)
502+ break;
503+ }
504+ }
505+ gtk_selection_data_free(selection_data);
506+ g_free(targets);
507+
508+ return NS_OK;
509+}
510+
511+NS_IMETHODIMP
512+nsClipboard::SupportsSelectionClipboard(PRBool *_retval)
513+{
514+ *_retval = PR_TRUE; // yeah, unix supports the selection clipboard
515+ return NS_OK;
516+}
517+
518+/* static */
519+GdkAtom
520+nsClipboard::GetSelectionAtom(PRInt32 aWhichClipboard)
521+{
522+ if (aWhichClipboard == kGlobalClipboard)
523+ return GDK_SELECTION_CLIPBOARD;
524+
525+ return GDK_SELECTION_PRIMARY;
526+}
527+
528+/* static */
529+GtkSelectionData *
530+nsClipboard::GetTargets(GdkAtom aWhichClipboard)
531+{
532+ GtkClipboard *clipboard = gtk_clipboard_get(aWhichClipboard);
533+ return wait_for_contents(clipboard, gdk_atom_intern("TARGETS", FALSE));
534+}
535+
536+nsITransferable *
537+nsClipboard::GetTransferable(PRInt32 aWhichClipboard)
538+{
539+ nsITransferable *retval;
540+
541+ if (aWhichClipboard == kSelectionClipboard)
542+ retval = mSelectionTransferable.get();
543+ else
544+ retval = mGlobalTransferable.get();
545+
546+ return retval;
547+}
548+
549+void
550+nsClipboard::AddTarget(GdkAtom aName, GdkAtom aClipboard)
551+{
552+ gtk_selection_add_target(mWidget, aClipboard, aName, 0);
553+}
554+
555+void
556+nsClipboard::SelectionGetEvent (GtkWidget *aWidget,
557+ GtkSelectionData *aSelectionData,
558+ guint aTime)
559+{
560+ // Someone has asked us to hand them something. The first thing
561+ // that we want to do is see if that something includes text. If
562+ // it does, try to give it text/unicode after converting it to
563+ // utf-8.
564+
565+ PRInt32 whichClipboard;
566+
567+ // which clipboard?
568+ if (aSelectionData->selection == GDK_SELECTION_PRIMARY)
569+ whichClipboard = kSelectionClipboard;
570+ else if (aSelectionData->selection == GDK_SELECTION_CLIPBOARD)
571+ whichClipboard = kGlobalClipboard;
572+ else
573+ return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
574+
575+ nsCOMPtr<nsITransferable> trans = GetTransferable(whichClipboard);
576+
577+ nsresult rv;
578+ nsCOMPtr<nsISupports> item;
579+ PRUint32 len;
580+
581+ // Check to see if the selection data includes any of the string
582+ // types that we support.
583+ if (aSelectionData->target == gdk_atom_intern ("STRING", FALSE) ||
584+ aSelectionData->target == gdk_atom_intern ("TEXT", FALSE) ||
585+ aSelectionData->target == gdk_atom_intern ("COMPOUND_TEXT", FALSE) ||
586+ aSelectionData->target == gdk_atom_intern ("UTF8_STRING", FALSE)) {
587+ // Try to convert our internal type into a text string. Get
588+ // the transferable for this clipboard and try to get the
589+ // text/unicode type for it.
590+ rv = trans->GetTransferData("text/unicode", getter_AddRefs(item),
591+ &len);
592+ if (!item || NS_FAILED(rv))
593+ return;
594+
595+ nsCOMPtr<nsISupportsString> wideString;
596+ wideString = do_QueryInterface(item);
597+ if (!wideString)
598+ return;
599+
600+ nsAutoString ucs2string;
601+ wideString->GetData(ucs2string);
602+ char *utf8string = ToNewUTF8String(ucs2string);
603+ if (!utf8string)
604+ return;
605+
606+ gtk_selection_data_set_text (aSelectionData, utf8string,
607+ strlen(utf8string));
608+
609+ nsMemory::Free(utf8string);
610+ return;
611+ }
612+
613+ // Try to match up the selection data target to something our
614+ // transferable provides.
615+ gchar *target_name = gdk_atom_name(aSelectionData->target);
616+ if (!target_name)
617+ return;
618+
619+ rv = trans->GetTransferData(target_name, getter_AddRefs(item), &len);
620+ // nothing found?
621+ if (!item || NS_FAILED(rv)) {
622+ g_free(target_name);
623+ return;
624+ }
625+
626+ void *primitive_data = nsnull;
627+ nsPrimitiveHelpers::CreateDataFromPrimitive(target_name, item,
628+ &primitive_data, len);
629+
630+ if (primitive_data) {
631+ // Check to see if the selection data is text/html
632+ if (aSelectionData->target == gdk_atom_intern (kHTMLMime, FALSE)) {
633+ /*
634+ * "text/html" can be encoded UCS2. It is recommended that
635+ * documents transmitted as UCS2 always begin with a ZERO-WIDTH
636+ * NON-BREAKING SPACE character (hexadecimal FEFF, also called
637+ * Byte Order Mark (BOM)). Adding BOM can help other app to
638+ * detect mozilla use UCS2 encoding when copy-paste.
639+ */
640+ guchar *buffer = (guchar *)
641+ nsMemory::Alloc((len * sizeof(guchar)) + sizeof(PRUnichar));
642+ if (!buffer)
643+ return;
644+ PRUnichar prefix = 0xFEFF;
645+ memcpy(buffer, &prefix, sizeof(prefix));
646+ memcpy(buffer + sizeof(prefix), primitive_data, len);
647+ nsMemory::Free((guchar *)primitive_data);
648+ primitive_data = (guchar *)buffer;
649+ len += sizeof(prefix);
650+ }
651+
652+ gtk_selection_data_set(aSelectionData, aSelectionData->target,
653+ 8, /* 8 bits in a unit */
654+ (const guchar *)primitive_data, len);
655+ nsMemory::Free(primitive_data);
656+ }
657+
658+ g_free(target_name);
659+
660+}
661+
662+void
663+nsClipboard::SelectionClearEvent (GtkWidget *aWidget,
664+ GdkEventSelection *aEvent)
665+{
666+ PRInt32 whichClipboard;
667+
668+ // which clipboard?
669+ if (aEvent->selection == GDK_SELECTION_PRIMARY)
670+ whichClipboard = kSelectionClipboard;
671+ else if (aEvent->selection == GDK_SELECTION_CLIPBOARD)
672+ whichClipboard = kGlobalClipboard;
673+ else
674+ return; // THAT AIN'T NO CLIPBOARD I EVER HEARD OF
675+
676+ EmptyClipboard(whichClipboard);
677+}
678+
679+void
680+invisible_selection_get_cb (GtkWidget *aWidget,
681+ GtkSelectionData *aSelectionData,
682+ guint aTime,
683+ guint aInfo,
684+ nsClipboard *aClipboard)
685+{
686+ aClipboard->SelectionGetEvent(aWidget, aSelectionData, aTime);
687+}
688+
689+gboolean
690+selection_clear_event_cb (GtkWidget *aWidget,
691+ GdkEventSelection *aEvent,
692+ nsClipboard *aClipboard)
693+{
694+ aClipboard->SelectionClearEvent(aWidget, aEvent);
695+ return TRUE;
696+}
697+
698+/*
699+ * when copy-paste, mozilla wants data encoded using UCS2,
700+ * other app such as StarOffice use "text/html"(RFC2854).
701+ * This function convert data(got from GTK clipboard)
702+ * to data mozilla wanted.
703+ *
704+ * data from GTK clipboard can be 3 forms:
705+ * 1. From current mozilla
706+ * "text/html", charset = utf-16
707+ * 2. From old version mozilla or mozilla-based app
708+ * content("body" only), charset = utf-16
709+ * 3. From other app who use "text/html" when copy-paste
710+ * "text/html", has "charset" info
711+ *
712+ * data : got from GTK clipboard
713+ * dataLength: got from GTK clipboard
714+ * body : pass to Mozilla
715+ * bodyLength: pass to Mozilla
716+ */
717+void ConvertHTMLtoUCS2(guchar * data, PRInt32 dataLength,
718+ PRUnichar** unicodeData, PRInt32& outUnicodeLen)
719+{
720+ nsCAutoString charset;
721+ GetHTMLCharset(data, dataLength, charset);// get charset of HTML
722+ if (charset.EqualsLiteral("UTF-16")) {//current mozilla
723+ outUnicodeLen = (dataLength / 2) - 1;
724+ *unicodeData = reinterpret_cast<PRUnichar*>
725+ (nsMemory::Alloc((outUnicodeLen + sizeof('\0')) *
726+ sizeof(PRUnichar)));
727+ if (*unicodeData) {
728+ memcpy(*unicodeData, data + sizeof(PRUnichar),
729+ outUnicodeLen * sizeof(PRUnichar));
730+ (*unicodeData)[outUnicodeLen] = '\0';
731+ }
732+ } else if (charset.EqualsLiteral("UNKNOWN")) {
733+ outUnicodeLen = 0;
734+ return;
735+ } else {
736+ // app which use "text/html" to copy&paste
737+ nsCOMPtr<nsIUnicodeDecoder> decoder;
738+ nsresult rv;
739+ // get the decoder
740+ nsCOMPtr<nsICharsetConverterManager> ccm =
741+ do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
742+ if (NS_FAILED(rv)) {
743+#ifdef DEBUG_CLIPBOARD
744+ g_print(" can't get CHARSET CONVERTER MANAGER service\n");
745+#endif
746+ outUnicodeLen = 0;
747+ return;
748+ }
749+ rv = ccm->GetUnicodeDecoder(charset.get(), getter_AddRefs(decoder));
750+ if (NS_FAILED(rv)) {
751+#ifdef DEBUG_CLIPBOARD
752+ g_print(" get unicode decoder error\n");
753+#endif
754+ outUnicodeLen = 0;
755+ return;
756+ }
757+ // converting
758+ decoder->GetMaxLength((const char *)data, dataLength, &outUnicodeLen);
759+ // |outUnicodeLen| is number of chars
760+ if (outUnicodeLen) {
761+ *unicodeData = reinterpret_cast<PRUnichar*>
762+ (nsMemory::Alloc((outUnicodeLen + sizeof('\0')) *
763+ sizeof(PRUnichar)));
764+ if (*unicodeData) {
765+ PRInt32 numberTmp = dataLength;
766+ decoder->Convert((const char *)data, &numberTmp,
767+ *unicodeData, &outUnicodeLen);
768+#ifdef DEBUG_CLIPBOARD
769+ if (numberTmp != dataLength)
770+ printf("didn't consume all the bytes\n");
771+#endif
772+ // null terminate. Convert() doesn't do it for us
773+ (*unicodeData)[outUnicodeLen] = '\0';
774+ }
775+ } // if valid length
776+ }
777+}
778+
779+/*
780+ * get "charset" information from clipboard data
781+ * return value can be:
782+ * 1. "UTF-16": mozilla or "text/html" with "charset=utf-16"
783+ * 2. "UNKNOWN": mozilla can't detect what encode it use
784+ * 3. other: "text/html" with other charset than utf-16
785+ */
786+void GetHTMLCharset(guchar * data, PRInt32 dataLength, nsCString& str)
787+{
788+ // if detect "FFFE" or "FEFF", assume UTF-16
789+ PRUnichar* beginChar = (PRUnichar*)data;
790+ if ((beginChar[0] == 0xFFFE) || (beginChar[0] == 0xFEFF)) {
791+ str.AssignLiteral("UTF-16");
792+ return;
793+ }
794+ // no "FFFE" and "FEFF", assume ASCII first to find "charset" info
795+ const nsDependentCString htmlStr((const char *)data, dataLength);
796+ nsACString::const_iterator start, end;
797+ htmlStr.BeginReading(start);
798+ htmlStr.EndReading(end);
799+ nsACString::const_iterator valueStart(start), valueEnd(start);
800+
801+ if (CaseInsensitiveFindInReadable(
802+ NS_LITERAL_CSTRING("CONTENT=\"text/html;"),
803+ start, end)) {
804+ start = end;
805+ htmlStr.EndReading(end);
806+
807+ if (CaseInsensitiveFindInReadable(
808+ NS_LITERAL_CSTRING("charset="),
809+ start, end)) {
810+ valueStart = end;
811+ start = end;
812+ htmlStr.EndReading(end);
813+
814+ if (FindCharInReadable('"', start, end))
815+ valueEnd = start;
816+ }
817+ }
818+ // find "charset" in HTML
819+ if (valueStart != valueEnd) {
820+ str = Substring(valueStart, valueEnd);
821+ ToUpperCase(str);
822+#ifdef DEBUG_CLIPBOARD
823+ printf("Charset of HTML = %s\n", charsetUpperStr.get());
824+#endif
825+ return;
826+ }
827+ str.AssignLiteral("UNKNOWN");
828+}
829+
830+static void
831+DispatchSelectionNotifyEvent(GtkWidget *widget, XEvent *xevent)
832+{
833+ GdkEvent event;
834+ event.selection.type = GDK_SELECTION_NOTIFY;
835+ event.selection.window = widget->window;
836+ event.selection.selection = gdk_x11_xatom_to_atom(xevent->xselection.selection);
837+ event.selection.target = gdk_x11_xatom_to_atom(xevent->xselection.target);
838+ event.selection.property = gdk_x11_xatom_to_atom(xevent->xselection.property);
839+ event.selection.time = xevent->xselection.time;
840+
841+ gtk_widget_event(widget, &event);
842+}
843+
844+static void
845+DispatchPropertyNotifyEvent(GtkWidget *widget, XEvent *xevent)
846+{
847+ if (((GdkWindowObject *) widget->window)->event_mask & GDK_PROPERTY_CHANGE_MASK) {
848+ GdkEvent event;
849+ event.property.type = GDK_PROPERTY_NOTIFY;
850+ event.property.window = widget->window;
851+ event.property.atom = gdk_x11_xatom_to_atom(xevent->xproperty.atom);
852+ event.property.time = xevent->xproperty.time;
853+ event.property.state = xevent->xproperty.state;
854+
855+ gtk_widget_event(widget, &event);
856+ }
857+}
858+
859+struct checkEventContext
860+{
861+ GtkWidget *cbWidget;
862+ Atom selAtom;
863+};
864+
865+static Bool
866+checkEventProc(Display *display, XEvent *event, XPointer arg)
867+{
868+ checkEventContext *context = (checkEventContext *) arg;
869+
870+ if (event->xany.type == SelectionNotify ||
871+ (event->xany.type == PropertyNotify &&
872+ event->xproperty.atom == context->selAtom)) {
873+
874+ GdkWindow *cbWindow = gdk_window_lookup(event->xany.window);
875+ if (cbWindow) {
876+ GtkWidget *cbWidget = NULL;
877+ gdk_window_get_user_data(cbWindow, (gpointer *)&cbWidget);
878+ if (cbWidget && GTK_IS_WIDGET(cbWidget)) {
879+ context->cbWidget = cbWidget;
880+ return True;
881+ }
882+ }
883+ }
884+
885+ return False;
886+}
887+
888+// Idle timeout for receiving selection and property notify events (microsec)
889+static const int kClipboardTimeout = 500000;
890+
891+static void
892+wait_for_retrieval(GtkClipboard *clipboard, retrieval_context *r_context)
893+{
894+ if (r_context->completed) // the request completed synchronously
895+ return;
896+
897+ Display *xDisplay = GDK_DISPLAY();
898+ checkEventContext context;
899+ context.cbWidget = NULL;
900+ context.selAtom = gdk_x11_atom_to_xatom(gdk_atom_intern("GDK_SELECTION",
901+ FALSE));
902+
903+ // Send X events which are relevant to the ongoing selection retrieval
904+ // to the clipboard widget. Wait until either the operation completes, or
905+ // we hit our timeout. All other X events remain queued.
906+
907+ int select_result;
908+
909+#ifdef POLL_WITH_XCONNECTIONNUMBER
910+ struct pollfd fds[1];
911+ fds[0].fd = XConnectionNumber(xDisplay);
912+ fds[0].events = POLLIN;
913+#else
914+ int cnumber = ConnectionNumber(xDisplay);
915+ fd_set select_set;
916+ FD_ZERO(&select_set);
917+ FD_SET(cnumber, &select_set);
918+ ++cnumber;
919+ struct timeval tv;
920+#endif
921+
922+ do {
923+ XEvent xevent;
924+
925+ while (XCheckIfEvent(xDisplay, &xevent, checkEventProc,
926+ (XPointer) &context)) {
927+
928+ if (xevent.xany.type == SelectionNotify)
929+ DispatchSelectionNotifyEvent(context.cbWidget, &xevent);
930+ else
931+ DispatchPropertyNotifyEvent(context.cbWidget, &xevent);
932+
933+ if (r_context->completed)
934+ return;
935+ }
936+
937+#ifdef POLL_WITH_XCONNECTIONNUMBER
938+ select_result = poll(fds, 1, kClipboardTimeout / 1000);
939+#else
940+ tv.tv_sec = 0;
941+ tv.tv_usec = kClipboardTimeout;
942+ select_result = select(cnumber, &select_set, NULL, NULL, &tv);
943+#endif
944+ } while (select_result == 1);
945+
946+#ifdef DEBUG_CLIPBOARD
947+ printf("exceeded clipboard timeout\n");
948+#endif
949+}
950+
951+static void
952+clipboard_contents_received(GtkClipboard *clipboard,
953+ GtkSelectionData *selection_data,
954+ gpointer data)
955+{
956+ retrieval_context *context = static_cast<retrieval_context *>(data);
957+ context->completed = PR_TRUE;
958+
959+ if (selection_data->length >= 0)
960+ context->data = gtk_selection_data_copy(selection_data);
961+}
962+
963+
964+static GtkSelectionData *
965+wait_for_contents(GtkClipboard *clipboard, GdkAtom target)
966+{
967+ retrieval_context context;
968+ gtk_clipboard_request_contents(clipboard, target,
969+ clipboard_contents_received,
970+ &context);
971+
972+ wait_for_retrieval(clipboard, &context);
973+ return static_cast<GtkSelectionData *>(context.data);
974+}
975+
976+static void
977+clipboard_text_received(GtkClipboard *clipboard,
978+ const gchar *text,
979+ gpointer data)
980+{
981+ retrieval_context *context = static_cast<retrieval_context *>(data);
982+ context->completed = PR_TRUE;
983+ context->data = g_strdup(text);
984+}
985+
986+static gchar *
987+wait_for_text(GtkClipboard *clipboard)
988+{
989+ retrieval_context context;
990+ gtk_clipboard_request_text(clipboard, clipboard_text_received, &context);
991+
992+ wait_for_retrieval(clipboard, &context);
993+ return static_cast<gchar *>(context.data);
994+}
995diff --git a/widget/src/headless/nsClipboard.h b/widget/src/headless/nsClipboard.h
996new file mode 100644
997index 0000000..dc690c0
998--- /dev/null
999+++ b/widget/src/headless/nsClipboard.h
1000@@ -0,0 +1,93 @@
1001+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
1002+/* vim:expandtab:shiftwidth=4:tabstop=4:
1003+ */
1004+/* ***** BEGIN LICENSE BLOCK *****
1005+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
1006+ *
1007+ * The contents of this file are subject to the Mozilla Public License Version
1008+ * 1.1 (the "License"); you may not use this file except in compliance with
1009+ * the License. You may obtain a copy of the License at
1010+ * http://www.mozilla.org/MPL/
1011+ *
1012+ * Software distributed under the License is distributed on an "AS IS" basis,
1013+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
1014+ * for the specific language governing rights and limitations under the
1015+ * License.
1016+ *
1017+ * The Original Code is mozilla.org code.
1018+ *
1019+ * The Initial Developer of the Original Code is Christopher Blizzard
1020+ * <blizzard@mozilla.org>. Portions created by the Initial Developer
1021+ * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
1022+ *
1023+ * Contributor(s):
1024+ *
1025+ * Alternatively, the contents of this file may be used under the terms of
1026+ * either the GNU General Public License Version 2 or later (the "GPL"), or
1027+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
1028+ * in which case the provisions of the GPL or the LGPL are applicable instead
1029+ * of those above. If you wish to allow use of your version of this file only
1030+ * under the terms of either the GPL or the LGPL, and not to allow others to
1031+ * use your version of this file under the terms of the MPL, indicate your
1032+ * decision by deleting the provisions above and replace them with the notice
1033+ * and other provisions required by the GPL or the LGPL. If you do not delete
1034+ * the provisions above, a recipient may use your version of this file under
1035+ * the terms of any one of the MPL, the GPL or the LGPL.
1036+ *
1037+ * ***** END LICENSE BLOCK ***** */
1038+
1039+#ifndef __nsClipboard_h_
1040+#define __nsClipboard_h_
1041+
1042+#include "nsIClipboard.h"
1043+#include "nsClipboardPrivacyHandler.h"
1044+#include "nsAutoPtr.h"
1045+#include <gtk/gtk.h>
1046+
1047+class nsClipboard : public nsIClipboard
1048+{
1049+public:
1050+ nsClipboard();
1051+ virtual ~nsClipboard();
1052+
1053+ NS_DECL_ISUPPORTS
1054+
1055+ NS_DECL_NSICLIPBOARD
1056+
1057+ // Make sure we are initialized, called from the factory
1058+ // constructor
1059+ nsresult Init (void);
1060+ // Someone requested the selection from the hidden widget
1061+ void SelectionGetEvent (GtkWidget *aWidget,
1062+ GtkSelectionData *aSelectionData,
1063+ guint aTime);
1064+ void SelectionClearEvent (GtkWidget *aWidget,
1065+ GdkEventSelection *aEvent);
1066+
1067+
1068+private:
1069+ // Utility methods
1070+ static GdkAtom GetSelectionAtom (PRInt32 aWhichClipboard);
1071+ static GtkSelectionData *GetTargets (GdkAtom aWhichClipboard);
1072+
1073+ // Get our hands on the correct transferable, given a specific
1074+ // clipboard
1075+ nsITransferable *GetTransferable (PRInt32 aWhichClipboard);
1076+
1077+ // Add a target type to the hidden widget
1078+ void AddTarget (GdkAtom aName,
1079+ GdkAtom aClipboard);
1080+
1081+ // The hidden widget where we do all of our operations
1082+ GtkWidget *mWidget;
1083+ // Hang on to our owners and transferables so we can transfer data
1084+ // when asked.
1085+ nsCOMPtr<nsIClipboardOwner> mSelectionOwner;
1086+ nsCOMPtr<nsIClipboardOwner> mGlobalOwner;
1087+ nsCOMPtr<nsITransferable> mSelectionTransferable;
1088+ nsCOMPtr<nsITransferable> mGlobalTransferable;
1089+ nsRefPtr<nsClipboardPrivacyHandler> mPrivacyHandler;
1090+
1091+};
1092+
1093+#endif /* __nsClipboard_h_ */
1094diff --git a/widget/src/headless/nsIImageToPixbuf.h b/widget/src/headless/nsIImageToPixbuf.h
1095new file mode 100644
1096index 0000000..1c46015
1097--- /dev/null
1098+++ b/widget/src/headless/nsIImageToPixbuf.h
1099@@ -0,0 +1,62 @@
1100+/* ***** BEGIN LICENSE BLOCK *****
1101+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
1102+ *
1103+ * The contents of this file are subject to the Mozilla Public License Version
1104+ * 1.1 (the "License"); you may not use this file except in compliance with
1105+ * the License. You may obtain a copy of the License at
1106+ * http://www.mozilla.org/MPL/
1107+ *
1108+ * Software distributed under the License is distributed on an "AS IS" basis,
1109+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
1110+ * for the specific language governing rights and limitations under the
1111+ * License.
1112+ *
1113+ * The Original Code is mozilla.org widget code.
1114+ *
1115+ * The Initial Developer of the Original Code is
1116+ * Christian Biesinger <cbiesinger@web.de>.
1117+ * Portions created by the Initial Developer are Copyright (C) 2006
1118+ * the Initial Developer. All Rights Reserved.
1119+ *
1120+ * Contributor(s):
1121+ *
1122+ * Alternatively, the contents of this file may be used under the terms of
1123+ * either the GNU General Public License Version 2 or later (the "GPL"), or
1124+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
1125+ * in which case the provisions of the GPL or the LGPL are applicable instead
1126+ * of those above. If you wish to allow use of your version of this file only
1127+ * under the terms of either the GPL or the LGPL, and not to allow others to
1128+ * use your version of this file under the terms of the MPL, indicate your
1129+ * decision by deleting the provisions above and replace them with the notice
1130+ * and other provisions required by the GPL or the LGPL. If you do not delete
1131+ * the provisions above, a recipient may use your version of this file under
1132+ * the terms of any one of the MPL, the GPL or the LGPL.
1133+ *
1134+ * ***** END LICENSE BLOCK ***** */
1135+
1136+#ifndef NSIIMAGETOPIXBUF_H_
1137+#define NSIIMAGETOPIXBUF_H_
1138+
1139+#include "nsISupports.h"
1140+
1141+// dfa4ac93-83f2-4ab8-9b2a-0ff7022aebe2
1142+#define NSIIMAGETOPIXBUF_IID \
1143+{ 0xdfa4ac93, 0x83f2, 0x4ab8, \
1144+ { 0x9b, 0x2a, 0x0f, 0xf7, 0x02, 0x2a, 0xeb, 0xe2 } }
1145+
1146+class nsIImage;
1147+typedef struct _GdkPixbuf GdkPixbuf;
1148+
1149+/**
1150+ * An interface that allows converting an nsIImage to a GdkPixbuf*.
1151+ */
1152+class nsIImageToPixbuf : public nsISupports {
1153+ public:
1154+ NS_DECLARE_STATIC_IID_ACCESSOR(NSIIMAGETOPIXBUF_IID)
1155+
1156+ NS_IMETHOD_(GdkPixbuf*) ConvertImageToPixbuf(nsIImage* aImage) = 0;
1157+};
1158+
1159+NS_DEFINE_STATIC_IID_ACCESSOR(nsIImageToPixbuf, NSIIMAGETOPIXBUF_IID)
1160+
1161+#endif
1162diff --git a/widget/src/headless/nsImageToPixbuf.cpp b/widget/src/headless/nsImageToPixbuf.cpp
1163new file mode 100644
1164index 0000000..496815c
1165--- /dev/null
1166+++ b/widget/src/headless/nsImageToPixbuf.cpp
1167@@ -0,0 +1,196 @@
1168+/* vim:set sw=4 sts=4 et cin: */
1169+/* ***** BEGIN LICENSE BLOCK *****
1170+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
1171+ *
1172+ * The contents of this file are subject to the Mozilla Public License Version
1173+ * 1.1 (the "License"); you may not use this file except in compliance with
1174+ * the License. You may obtain a copy of the License at
1175+ * http://www.mozilla.org/MPL/
1176+ *
1177+ * Software distributed under the License is distributed on an "AS IS" basis,
1178+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
1179+ * for the specific language governing rights and limitations under the
1180+ * License.
1181+ *
1182+ * The Original Code is mozilla.org widget code.
1183+ *
1184+ * The Initial Developer of the Original Code is
1185+ * Christian Biesinger <cbiesinger@web.de>.
1186+ * Portions created by the Initial Developer are Copyright (C) 2006
1187+ * the Initial Developer. All Rights Reserved.
1188+ *
1189+ * Contributor(s):
1190+ *
1191+ * Alternatively, the contents of this file may be used under the terms of
1192+ * either the GNU General Public License Version 2 or later (the "GPL"), or
1193+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
1194+ * in which case the provisions of the GPL or the LGPL are applicable instead
1195+ * of those above. If you wish to allow use of your version of this file only
1196+ * under the terms of either the GPL or the LGPL, and not to allow others to
1197+ * use your version of this file under the terms of the MPL, indicate your
1198+ * decision by deleting the provisions above and replace them with the notice
1199+ * and other provisions required by the GPL or the LGPL. If you do not delete
1200+ * the provisions above, a recipient may use your version of this file under
1201+ * the terms of any one of the MPL, the GPL or the LGPL.
1202+ *
1203+ * ***** END LICENSE BLOCK ***** */
1204+
1205+#include <gdk-pixbuf/gdk-pixbuf.h>
1206+
1207+#include "gfxASurface.h"
1208+#include "gfxImageSurface.h"
1209+#include "gfxContext.h"
1210+
1211+#include "nsIImage.h"
1212+
1213+#include "nsAutoPtr.h"
1214+
1215+#include "nsImageToPixbuf.h"
1216+
1217+NS_IMPL_ISUPPORTS1(nsImageToPixbuf, nsIImageToPixbuf)
1218+
1219+inline unsigned char
1220+unpremultiply (unsigned char color,
1221+ unsigned char alpha)
1222+{
1223+ if (alpha == 0)
1224+ return 0;
1225+ // plus alpha/2 to round instead of truncate
1226+ return (color * 255 + alpha / 2) / alpha;
1227+}
1228+
1229+NS_IMETHODIMP_(GdkPixbuf*)
1230+nsImageToPixbuf::ConvertImageToPixbuf(nsIImage* aImage)
1231+{
1232+ return ImageToPixbuf(aImage);
1233+}
1234+
1235+GdkPixbuf*
1236+nsImageToPixbuf::ImageToPixbuf(nsIImage* aImage)
1237+{
1238+ PRInt32 width = aImage->GetWidth(),
1239+ height = aImage->GetHeight();
1240+
1241+ nsRefPtr<gfxPattern> pattern;
1242+ aImage->GetPattern(getter_AddRefs(pattern));
1243+
1244+ return PatternToPixbuf(pattern, width, height);
1245+}
1246+
1247+GdkPixbuf*
1248+nsImageToPixbuf::ImgSurfaceToPixbuf(gfxImageSurface* aImgSurface, PRInt32 aWidth, PRInt32 aHeight)
1249+{
1250+ GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, PR_TRUE, 8,
1251+ aWidth, aHeight);
1252+ if (!pixbuf)
1253+ return nsnull;
1254+
1255+ PRUint32 rowstride = gdk_pixbuf_get_rowstride (pixbuf);
1256+ guchar* pixels = gdk_pixbuf_get_pixels (pixbuf);
1257+
1258+ long cairoStride = aImgSurface->Stride();
1259+ unsigned char* cairoData = aImgSurface->Data();
1260+
1261+ gfxASurface::gfxImageFormat format = aImgSurface->Format();
1262+
1263+ for (PRInt32 row = 0; row < aHeight; ++row) {
1264+ for (PRInt32 col = 0; col < aWidth; ++col) {
1265+ guchar* pixel = pixels + row * rowstride + 4 * col;
1266+
1267+ PRUint32* cairoPixel = reinterpret_cast<PRUint32*>
1268+ ((cairoData + row * cairoStride + 4 * col));
1269+
1270+ if (format == gfxASurface::ImageFormatARGB32) {
1271+ const PRUint8 a = (*cairoPixel >> 24) & 0xFF;
1272+ const PRUint8 r = unpremultiply((*cairoPixel >> 16) & 0xFF, a);
1273+ const PRUint8 g = unpremultiply((*cairoPixel >> 8) & 0xFF, a);
1274+ const PRUint8 b = unpremultiply((*cairoPixel >> 0) & 0xFF, a);
1275+
1276+ *pixel++ = r;
1277+ *pixel++ = g;
1278+ *pixel++ = b;
1279+ *pixel++ = a;
1280+ } else {
1281+ NS_ASSERTION(format == gfxASurface::ImageFormatRGB24,
1282+ "unexpected format");
1283+ const PRUint8 r = (*cairoPixel >> 16) & 0xFF;
1284+ const PRUint8 g = (*cairoPixel >> 8) & 0xFF;
1285+ const PRUint8 b = (*cairoPixel >> 0) & 0xFF;
1286+
1287+ *pixel++ = r;
1288+ *pixel++ = g;
1289+ *pixel++ = b;
1290+ *pixel++ = 0xFF; // A
1291+ }
1292+ }
1293+ }
1294+
1295+ return pixbuf;
1296+}
1297+
1298+GdkPixbuf*
1299+nsImageToPixbuf::SurfaceToPixbuf(gfxASurface* aSurface, PRInt32 aWidth, PRInt32 aHeight)
1300+{
1301+ if (aSurface->CairoStatus()) {
1302+ NS_ERROR("invalid surface");
1303+ return nsnull;
1304+ }
1305+
1306+ nsRefPtr<gfxImageSurface> imgSurface;
1307+ if (aSurface->GetType() == gfxASurface::SurfaceTypeImage) {
1308+ imgSurface = static_cast<gfxImageSurface*>
1309+ (static_cast<gfxASurface*>(aSurface));
1310+ } else {
1311+ imgSurface = new gfxImageSurface(gfxIntSize(aWidth, aHeight),
1312+ gfxImageSurface::ImageFormatARGB32);
1313+
1314+ if (!imgSurface)
1315+ return nsnull;
1316+
1317+ nsRefPtr<gfxContext> context = new gfxContext(imgSurface);
1318+ if (!context)
1319+ return nsnull;
1320+
1321+ context->SetOperator(gfxContext::OPERATOR_SOURCE);
1322+ context->SetSource(aSurface);
1323+ context->Paint();
1324+ }
1325+
1326+ return ImgSurfaceToPixbuf(imgSurface, aWidth, aHeight);
1327+}
1328+
1329+GdkPixbuf*
1330+nsImageToPixbuf::PatternToPixbuf(gfxPattern* aPattern, PRInt32 aWidth, PRInt32 aHeight)
1331+{
1332+ if (aPattern->CairoStatus()) {
1333+ NS_ERROR("invalid pattern");
1334+ return nsnull;
1335+ }
1336+
1337+ nsRefPtr<gfxImageSurface> imgSurface;
1338+ if (aPattern->GetType() == gfxPattern::PATTERN_SURFACE) {
1339+ nsRefPtr<gfxASurface> surface = aPattern->GetSurface();
1340+ if (surface->GetType() == gfxASurface::SurfaceTypeImage) {
1341+ imgSurface = static_cast<gfxImageSurface*>
1342+ (static_cast<gfxASurface*>(surface.get()));
1343+ }
1344+ }
1345+
1346+ if (!imgSurface) {
1347+ imgSurface = new gfxImageSurface(gfxIntSize(aWidth, aHeight),
1348+ gfxImageSurface::ImageFormatARGB32);
1349+
1350+ if (!imgSurface)
1351+ return nsnull;
1352+
1353+ nsRefPtr<gfxContext> context = new gfxContext(imgSurface);
1354+ if (!context)
1355+ return nsnull;
1356+
1357+ context->SetOperator(gfxContext::OPERATOR_SOURCE);
1358+ context->SetPattern(aPattern);
1359+ context->Paint();
1360+ }
1361+
1362+ return ImgSurfaceToPixbuf(imgSurface, aWidth, aHeight);
1363+}
1364diff --git a/widget/src/headless/nsImageToPixbuf.h b/widget/src/headless/nsImageToPixbuf.h
1365new file mode 100644
1366index 0000000..0e3f516
1367--- /dev/null
1368+++ b/widget/src/headless/nsImageToPixbuf.h
1369@@ -0,0 +1,71 @@
1370+/* vim:set sw=4 sts=4 et cin: */
1371+/* ***** BEGIN LICENSE BLOCK *****
1372+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
1373+ *
1374+ * The contents of this file are subject to the Mozilla Public License Version
1375+ * 1.1 (the "License"); you may not use this file except in compliance with
1376+ * the License. You may obtain a copy of the License at
1377+ * http://www.mozilla.org/MPL/
1378+ *
1379+ * Software distributed under the License is distributed on an "AS IS" basis,
1380+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
1381+ * for the specific language governing rights and limitations under the
1382+ * License.
1383+ *
1384+ * The Original Code is mozilla.org widget code.
1385+ *
1386+ * The Initial Developer of the Original Code is
1387+ * Christian Biesinger <cbiesinger@web.de>.
1388+ * Portions created by the Initial Developer are Copyright (C) 2006
1389+ * the Initial Developer. All Rights Reserved.
1390+ *
1391+ * Contributor(s):
1392+ *
1393+ * Alternatively, the contents of this file may be used under the terms of
1394+ * either the GNU General Public License Version 2 or later (the "GPL"), or
1395+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
1396+ * in which case the provisions of the GPL or the LGPL are applicable instead
1397+ * of those above. If you wish to allow use of your version of this file only
1398+ * under the terms of either the GPL or the LGPL, and not to allow others to
1399+ * use your version of this file under the terms of the MPL, indicate your
1400+ * decision by deleting the provisions above and replace them with the notice
1401+ * and other provisions required by the GPL or the LGPL. If you do not delete
1402+ * the provisions above, a recipient may use your version of this file under
1403+ * the terms of any one of the MPL, the GPL or the LGPL.
1404+ *
1405+ * ***** END LICENSE BLOCK ***** */
1406+
1407+#ifndef NSIMAGETOPIXBUF_H_
1408+#define NSIMAGETOPIXBUF_H_
1409+
1410+#include "nsIImageToPixbuf.h"
1411+
1412+class gfxASurface;
1413+class gfxPattern;
1414+class gfxImageSurface;
1415+
1416+class nsImageToPixbuf : public nsIImageToPixbuf {
1417+ public:
1418+ NS_DECL_ISUPPORTS
1419+ NS_IMETHOD_(GdkPixbuf*) ConvertImageToPixbuf(nsIImage* aImage);
1420+
1421+ // Friendlier version of ConvertImageToPixbuf for callers inside of
1422+ // widget
1423+ static GdkPixbuf* ImageToPixbuf(nsIImage* aImage);
1424+ static GdkPixbuf* SurfaceToPixbuf(gfxASurface* aSurface,
1425+ PRInt32 aWidth, PRInt32 aHeight);
1426+ static GdkPixbuf* PatternToPixbuf(gfxPattern* aPattern,
1427+ PRInt32 aWidth, PRInt32 aHeight);
1428+ private:
1429+ static GdkPixbuf* ImgSurfaceToPixbuf(gfxImageSurface* aImgSurface,
1430+ PRInt32 aWidth, PRInt32 aHeight);
1431+ ~nsImageToPixbuf() {}
1432+};
1433+
1434+
1435+// fc2389b8-c650-4093-9e42-b05e5f0685b7
1436+#define NS_IMAGE_TO_PIXBUF_CID \
1437+{ 0xfc2389b8, 0xc650, 0x4093, \
1438+ { 0x9e, 0x42, 0xb0, 0x5e, 0x5f, 0x06, 0x85, 0xb7 } }
1439+
1440+#endif
1441diff --git a/widget/src/headless/nsWidgetFactory.cpp b/widget/src/headless/nsWidgetFactory.cpp
1442index eb94333..a215988 100644
1443--- a/widget/src/headless/nsWidgetFactory.cpp
1444+++ b/widget/src/headless/nsWidgetFactory.cpp
1445@@ -46,6 +46,10 @@
1446 #include "nsWindow.h"
1447 #include "nsTransferable.h"
1448 #include "nsHTMLFormatConverter.h"
1449+#ifdef MOZ_X11
1450+#include "nsClipboardHelper.h"
1451+#include "nsClipboard.h"
1452+#endif
1453 //#include "nsFilePicker.h"
1454 #include "nsSound.h"
1455 #include "nsBidiKeyboard.h"
1456@@ -74,6 +78,10 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsLookAndFeel)
1457 NS_GENERIC_FACTORY_CONSTRUCTOR(nsTransferable)
1458 NS_GENERIC_FACTORY_CONSTRUCTOR(nsBidiKeyboard)
1459 NS_GENERIC_FACTORY_CONSTRUCTOR(nsHTMLFormatConverter)
1460+#ifdef MOZ_X11
1461+NS_GENERIC_FACTORY_CONSTRUCTOR(nsClipboardHelper)
1462+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsClipboard, Init)
1463+#endif
1464 NS_GENERIC_FACTORY_CONSTRUCTOR(nsSound)
1465 NS_GENERIC_FACTORY_CONSTRUCTOR(nsScreenManagerHeadless)
1466 //NS_GENERIC_FACTORY_CONSTRUCTOR(nsImageToPixbuf)
1467@@ -189,6 +197,16 @@ static const nsModuleComponentInfo components[] =
1468 NS_TRANSFERABLE_CID,
1469 "@mozilla.org/widget/transferable;1",
1470 nsTransferableConstructor },
1471+#ifdef MOZ_X11
1472+ { "Gtk Clipboard",
1473+ NS_CLIPBOARD_CID,
1474+ "@mozilla.org/widget/clipboard;1",
1475+ nsClipboardConstructor },
1476+ { "Clipboard Helper",
1477+ NS_CLIPBOARDHELPER_CID,
1478+ "@mozilla.org/widget/clipboardhelper;1",
1479+ nsClipboardHelperConstructor },
1480+#endif
1481 { "HTML Format Converter",
1482 NS_HTMLFORMATCONVERTER_CID,
1483 "@mozilla.org/widget/htmlformatconverter;1",
1484--
14851.6.0.4
1486
diff --git a/meta/packages/mozilla-headless/mozilla-headless/arm/jsautocfg.h b/meta/packages/mozilla-headless/mozilla-headless/arm/jsautocfg.h
deleted file mode 100644
index e9d37dee91..0000000000
--- a/meta/packages/mozilla-headless/mozilla-headless/arm/jsautocfg.h
+++ /dev/null
@@ -1,54 +0,0 @@
1#ifndef js_cpucfg___
2#define js_cpucfg___
3
4/* AUTOMATICALLY GENERATED - DO NOT EDIT, unless you are an OE dev :) */
5
6#define IS_LITTLE_ENDIAN 1
7#undef IS_BIG_ENDIAN
8
9#define JS_BYTES_PER_BYTE 1L
10#define JS_BYTES_PER_SHORT 2L
11#define JS_BYTES_PER_INT 4L
12#define JS_BYTES_PER_INT64 8L
13#define JS_BYTES_PER_LONG 4L
14#define JS_BYTES_PER_FLOAT 4L
15#define JS_BYTES_PER_DOUBLE 8L
16#define JS_BYTES_PER_WORD 4L
17#define JS_BYTES_PER_DWORD 8L
18
19#define JS_BITS_PER_BYTE 8L
20#define JS_BITS_PER_SHORT 16L
21#define JS_BITS_PER_INT 32L
22#define JS_BITS_PER_INT64 64L
23#define JS_BITS_PER_LONG 32L
24#define JS_BITS_PER_FLOAT 32L
25#define JS_BITS_PER_DOUBLE 64L
26#define JS_BITS_PER_WORD 32L
27
28#define JS_BITS_PER_BYTE_LOG2 3L
29#define JS_BITS_PER_SHORT_LOG2 4L
30#define JS_BITS_PER_INT_LOG2 5L
31#define JS_BITS_PER_INT64_LOG2 6L
32#define JS_BITS_PER_LONG_LOG2 5L
33#define JS_BITS_PER_FLOAT_LOG2 5L
34#define JS_BITS_PER_DOUBLE_LOG2 6L
35#define JS_BITS_PER_WORD_LOG2 5L
36
37#define JS_ALIGN_OF_SHORT 2L
38#define JS_ALIGN_OF_INT 4L
39#define JS_ALIGN_OF_LONG 4L
40#define JS_ALIGN_OF_INT64 8L
41#define JS_ALIGN_OF_FLOAT 4L
42#define JS_ALIGN_OF_DOUBLE 8L
43#define JS_ALIGN_OF_POINTER 4L
44#define JS_ALIGN_OF_WORD 4L
45
46#define JS_BYTES_PER_WORD_LOG2 2L
47#define JS_BYTES_PER_DWORD_LOG2 3L
48#define JS_WORDS_PER_DWORD_LOG2 1L
49
50#define JS_STACK_GROWTH_DIRECTION (-1)
51
52#define JS_HAVE_LONG_LONG
53
54#endif /* js_cpucfg___ */
diff --git a/meta/packages/mozilla-headless/mozilla-headless/i386/jsautocfg.h b/meta/packages/mozilla-headless/mozilla-headless/i386/jsautocfg.h
index 394271a7ea..7c7c76c396 100644
--- a/meta/packages/mozilla-headless/mozilla-headless/i386/jsautocfg.h
+++ b/meta/packages/mozilla-headless/mozilla-headless/i386/jsautocfg.h
@@ -6,46 +6,11 @@
6#define IS_LITTLE_ENDIAN 1 6#define IS_LITTLE_ENDIAN 1
7#undef IS_BIG_ENDIAN 7#undef IS_BIG_ENDIAN
8 8
9#define JS_BYTES_PER_BYTE 1L
10#define JS_BYTES_PER_SHORT 2L
11#define JS_BYTES_PER_INT 4L
12#define JS_BYTES_PER_INT64 8L
13#define JS_BYTES_PER_LONG 4L
14#define JS_BYTES_PER_FLOAT 4L
15#define JS_BYTES_PER_DOUBLE 8L
16#define JS_BYTES_PER_WORD 4L
17#define JS_BYTES_PER_DWORD 8L
18 9
19#define JS_BITS_PER_BYTE 8L 10#define JS_BYTES_PER_WORD 4L
20#define JS_BITS_PER_SHORT 16L 11#define JS_BYTES_PER_DOUBLE 8L
21#define JS_BITS_PER_INT 32L
22#define JS_BITS_PER_INT64 64L
23#define JS_BITS_PER_LONG 32L
24#define JS_BITS_PER_FLOAT 32L
25#define JS_BITS_PER_DOUBLE 64L
26#define JS_BITS_PER_WORD 32L
27
28#define JS_BITS_PER_BYTE_LOG2 3L
29#define JS_BITS_PER_SHORT_LOG2 4L
30#define JS_BITS_PER_INT_LOG2 5L
31#define JS_BITS_PER_INT64_LOG2 6L
32#define JS_BITS_PER_LONG_LOG2 5L
33#define JS_BITS_PER_FLOAT_LOG2 5L
34#define JS_BITS_PER_DOUBLE_LOG2 6L
35#define JS_BITS_PER_WORD_LOG2 5L 12#define JS_BITS_PER_WORD_LOG2 5L
36
37#define JS_ALIGN_OF_SHORT 2L
38#define JS_ALIGN_OF_INT 4L
39#define JS_ALIGN_OF_LONG 4L
40#define JS_ALIGN_OF_INT64 4L
41#define JS_ALIGN_OF_FLOAT 4L
42#define JS_ALIGN_OF_DOUBLE 4L
43#define JS_ALIGN_OF_POINTER 4L 13#define JS_ALIGN_OF_POINTER 4L
44#define JS_ALIGN_OF_WORD 4L
45
46#define JS_BYTES_PER_WORD_LOG2 2L
47#define JS_BYTES_PER_DWORD_LOG2 3L
48#define JS_WORDS_PER_DWORD_LOG2 1L
49 14
50#define JS_STACK_GROWTH_DIRECTION (-1) 15#define JS_STACK_GROWTH_DIRECTION (-1)
51 16
diff --git a/meta/packages/mozilla-headless/mozilla-headless/i486/jsautocfg.h b/meta/packages/mozilla-headless/mozilla-headless/i486/jsautocfg.h
index 394271a7ea..7c7c76c396 100644
--- a/meta/packages/mozilla-headless/mozilla-headless/i486/jsautocfg.h
+++ b/meta/packages/mozilla-headless/mozilla-headless/i486/jsautocfg.h
@@ -6,46 +6,11 @@
6#define IS_LITTLE_ENDIAN 1 6#define IS_LITTLE_ENDIAN 1
7#undef IS_BIG_ENDIAN 7#undef IS_BIG_ENDIAN
8 8
9#define JS_BYTES_PER_BYTE 1L
10#define JS_BYTES_PER_SHORT 2L
11#define JS_BYTES_PER_INT 4L
12#define JS_BYTES_PER_INT64 8L
13#define JS_BYTES_PER_LONG 4L
14#define JS_BYTES_PER_FLOAT 4L
15#define JS_BYTES_PER_DOUBLE 8L
16#define JS_BYTES_PER_WORD 4L
17#define JS_BYTES_PER_DWORD 8L
18 9
19#define JS_BITS_PER_BYTE 8L 10#define JS_BYTES_PER_WORD 4L
20#define JS_BITS_PER_SHORT 16L 11#define JS_BYTES_PER_DOUBLE 8L
21#define JS_BITS_PER_INT 32L
22#define JS_BITS_PER_INT64 64L
23#define JS_BITS_PER_LONG 32L
24#define JS_BITS_PER_FLOAT 32L
25#define JS_BITS_PER_DOUBLE 64L
26#define JS_BITS_PER_WORD 32L
27
28#define JS_BITS_PER_BYTE_LOG2 3L
29#define JS_BITS_PER_SHORT_LOG2 4L
30#define JS_BITS_PER_INT_LOG2 5L
31#define JS_BITS_PER_INT64_LOG2 6L
32#define JS_BITS_PER_LONG_LOG2 5L
33#define JS_BITS_PER_FLOAT_LOG2 5L
34#define JS_BITS_PER_DOUBLE_LOG2 6L
35#define JS_BITS_PER_WORD_LOG2 5L 12#define JS_BITS_PER_WORD_LOG2 5L
36
37#define JS_ALIGN_OF_SHORT 2L
38#define JS_ALIGN_OF_INT 4L
39#define JS_ALIGN_OF_LONG 4L
40#define JS_ALIGN_OF_INT64 4L
41#define JS_ALIGN_OF_FLOAT 4L
42#define JS_ALIGN_OF_DOUBLE 4L
43#define JS_ALIGN_OF_POINTER 4L 13#define JS_ALIGN_OF_POINTER 4L
44#define JS_ALIGN_OF_WORD 4L
45
46#define JS_BYTES_PER_WORD_LOG2 2L
47#define JS_BYTES_PER_DWORD_LOG2 3L
48#define JS_WORDS_PER_DWORD_LOG2 1L
49 14
50#define JS_STACK_GROWTH_DIRECTION (-1) 15#define JS_STACK_GROWTH_DIRECTION (-1)
51 16
diff --git a/meta/packages/mozilla-headless/mozilla-headless/i586/jsautocfg.h b/meta/packages/mozilla-headless/mozilla-headless/i586/jsautocfg.h
index 394271a7ea..7c7c76c396 100644
--- a/meta/packages/mozilla-headless/mozilla-headless/i586/jsautocfg.h
+++ b/meta/packages/mozilla-headless/mozilla-headless/i586/jsautocfg.h
@@ -6,46 +6,11 @@
6#define IS_LITTLE_ENDIAN 1 6#define IS_LITTLE_ENDIAN 1
7#undef IS_BIG_ENDIAN 7#undef IS_BIG_ENDIAN
8 8
9#define JS_BYTES_PER_BYTE 1L
10#define JS_BYTES_PER_SHORT 2L
11#define JS_BYTES_PER_INT 4L
12#define JS_BYTES_PER_INT64 8L
13#define JS_BYTES_PER_LONG 4L
14#define JS_BYTES_PER_FLOAT 4L
15#define JS_BYTES_PER_DOUBLE 8L
16#define JS_BYTES_PER_WORD 4L
17#define JS_BYTES_PER_DWORD 8L
18 9
19#define JS_BITS_PER_BYTE 8L 10#define JS_BYTES_PER_WORD 4L
20#define JS_BITS_PER_SHORT 16L 11#define JS_BYTES_PER_DOUBLE 8L
21#define JS_BITS_PER_INT 32L
22#define JS_BITS_PER_INT64 64L
23#define JS_BITS_PER_LONG 32L
24#define JS_BITS_PER_FLOAT 32L
25#define JS_BITS_PER_DOUBLE 64L
26#define JS_BITS_PER_WORD 32L
27
28#define JS_BITS_PER_BYTE_LOG2 3L
29#define JS_BITS_PER_SHORT_LOG2 4L
30#define JS_BITS_PER_INT_LOG2 5L
31#define JS_BITS_PER_INT64_LOG2 6L
32#define JS_BITS_PER_LONG_LOG2 5L
33#define JS_BITS_PER_FLOAT_LOG2 5L
34#define JS_BITS_PER_DOUBLE_LOG2 6L
35#define JS_BITS_PER_WORD_LOG2 5L 12#define JS_BITS_PER_WORD_LOG2 5L
36
37#define JS_ALIGN_OF_SHORT 2L
38#define JS_ALIGN_OF_INT 4L
39#define JS_ALIGN_OF_LONG 4L
40#define JS_ALIGN_OF_INT64 4L
41#define JS_ALIGN_OF_FLOAT 4L
42#define JS_ALIGN_OF_DOUBLE 4L
43#define JS_ALIGN_OF_POINTER 4L 13#define JS_ALIGN_OF_POINTER 4L
44#define JS_ALIGN_OF_WORD 4L
45
46#define JS_BYTES_PER_WORD_LOG2 2L
47#define JS_BYTES_PER_DWORD_LOG2 3L
48#define JS_WORDS_PER_DWORD_LOG2 1L
49 14
50#define JS_STACK_GROWTH_DIRECTION (-1) 15#define JS_STACK_GROWTH_DIRECTION (-1)
51 16
diff --git a/meta/packages/mozilla-headless/mozilla-headless/i686/jsautocfg.h b/meta/packages/mozilla-headless/mozilla-headless/i686/jsautocfg.h
index 394271a7ea..7c7c76c396 100644
--- a/meta/packages/mozilla-headless/mozilla-headless/i686/jsautocfg.h
+++ b/meta/packages/mozilla-headless/mozilla-headless/i686/jsautocfg.h
@@ -6,46 +6,11 @@
6#define IS_LITTLE_ENDIAN 1 6#define IS_LITTLE_ENDIAN 1
7#undef IS_BIG_ENDIAN 7#undef IS_BIG_ENDIAN
8 8
9#define JS_BYTES_PER_BYTE 1L
10#define JS_BYTES_PER_SHORT 2L
11#define JS_BYTES_PER_INT 4L
12#define JS_BYTES_PER_INT64 8L
13#define JS_BYTES_PER_LONG 4L
14#define JS_BYTES_PER_FLOAT 4L
15#define JS_BYTES_PER_DOUBLE 8L
16#define JS_BYTES_PER_WORD 4L
17#define JS_BYTES_PER_DWORD 8L
18 9
19#define JS_BITS_PER_BYTE 8L 10#define JS_BYTES_PER_WORD 4L
20#define JS_BITS_PER_SHORT 16L 11#define JS_BYTES_PER_DOUBLE 8L
21#define JS_BITS_PER_INT 32L
22#define JS_BITS_PER_INT64 64L
23#define JS_BITS_PER_LONG 32L
24#define JS_BITS_PER_FLOAT 32L
25#define JS_BITS_PER_DOUBLE 64L
26#define JS_BITS_PER_WORD 32L
27
28#define JS_BITS_PER_BYTE_LOG2 3L
29#define JS_BITS_PER_SHORT_LOG2 4L
30#define JS_BITS_PER_INT_LOG2 5L
31#define JS_BITS_PER_INT64_LOG2 6L
32#define JS_BITS_PER_LONG_LOG2 5L
33#define JS_BITS_PER_FLOAT_LOG2 5L
34#define JS_BITS_PER_DOUBLE_LOG2 6L
35#define JS_BITS_PER_WORD_LOG2 5L 12#define JS_BITS_PER_WORD_LOG2 5L
36
37#define JS_ALIGN_OF_SHORT 2L
38#define JS_ALIGN_OF_INT 4L
39#define JS_ALIGN_OF_LONG 4L
40#define JS_ALIGN_OF_INT64 4L
41#define JS_ALIGN_OF_FLOAT 4L
42#define JS_ALIGN_OF_DOUBLE 4L
43#define JS_ALIGN_OF_POINTER 4L 13#define JS_ALIGN_OF_POINTER 4L
44#define JS_ALIGN_OF_WORD 4L
45
46#define JS_BYTES_PER_WORD_LOG2 2L
47#define JS_BYTES_PER_DWORD_LOG2 3L
48#define JS_WORDS_PER_DWORD_LOG2 1L
49 14
50#define JS_STACK_GROWTH_DIRECTION (-1) 15#define JS_STACK_GROWTH_DIRECTION (-1)
51 16
diff --git a/meta/packages/mozilla-headless/mozilla-headless/mozilla-jemalloc.patch b/meta/packages/mozilla-headless/mozilla-headless/mozilla-jemalloc.patch
new file mode 100644
index 0000000000..aabd6906e8
--- /dev/null
+++ b/meta/packages/mozilla-headless/mozilla-headless/mozilla-jemalloc.patch
@@ -0,0 +1,24 @@
1diff -r f1af606531f5 memory/jemalloc/jemalloc.h
2--- a/memory/jemalloc/jemalloc.h Sat Nov 22 20:22:22 2008 +0100
3+++ b/memory/jemalloc/jemalloc.h Mon Dec 01 16:53:06 2008 -0500
4@@ -45,14 +45,14 @@
5 } jemalloc_stats_t;
6
7 #ifndef MOZ_MEMORY_DARWIN
8-void *malloc(size_t size);
9-void *valloc(size_t size);
10-void *calloc(size_t num, size_t size);
11-void *realloc(void *ptr, size_t size);
12-void free(void *ptr);
13+void *malloc(size_t size) __THROW __attribute_malloc__ __wur;
14+void *valloc(size_t size) __THROW __attribute_malloc__ __wur;
15+void *calloc(size_t num, size_t size) __THROW __attribute_malloc__ __wur;
16+void *realloc(void *ptr, size_t size) __THROW __attribute_malloc__ __wur;
17+void free(void *ptr) __THROW __attribute_malloc__ __wur;
18 #endif
19
20-int posix_memalign(void **memptr, size_t alignment, size_t size);
21+int posix_memalign(void **memptr, size_t alignment, size_t size) __THROW __attribute_malloc__ __wur;
22 void *memalign(size_t alignment, size_t size);
23 size_t malloc_usable_size(const void *ptr);
24 void jemalloc_stats(jemalloc_stats_t *stats);
diff --git a/meta/packages/mozilla-headless/mozilla-headless/powerpc/jsautocfg.h b/meta/packages/mozilla-headless/mozilla-headless/powerpc/jsautocfg.h
deleted file mode 100644
index 408a5e4ac4..0000000000
--- a/meta/packages/mozilla-headless/mozilla-headless/powerpc/jsautocfg.h
+++ /dev/null
@@ -1,54 +0,0 @@
1#ifndef js_cpucfg___
2#define js_cpucfg___
3
4/* AUTOMATICALLY GENERATED - DO NOT EDIT */
5
6#undef IS_LITTLE_ENDIAN
7#define IS_BIG_ENDIAN 1
8
9#define JS_BYTES_PER_BYTE 1L
10#define JS_BYTES_PER_SHORT 2L
11#define JS_BYTES_PER_INT 4L
12#define JS_BYTES_PER_INT64 8L
13#define JS_BYTES_PER_LONG 4L
14#define JS_BYTES_PER_FLOAT 4L
15#define JS_BYTES_PER_DOUBLE 8L
16#define JS_BYTES_PER_WORD 4L
17#define JS_BYTES_PER_DWORD 8L
18
19#define JS_BITS_PER_BYTE 8L
20#define JS_BITS_PER_SHORT 16L
21#define JS_BITS_PER_INT 32L
22#define JS_BITS_PER_INT64 64L
23#define JS_BITS_PER_LONG 32L
24#define JS_BITS_PER_FLOAT 32L
25#define JS_BITS_PER_DOUBLE 64L
26#define JS_BITS_PER_WORD 32L
27
28#define JS_BITS_PER_BYTE_LOG2 3L
29#define JS_BITS_PER_SHORT_LOG2 4L
30#define JS_BITS_PER_INT_LOG2 5L
31#define JS_BITS_PER_INT64_LOG2 6L
32#define JS_BITS_PER_LONG_LOG2 5L
33#define JS_BITS_PER_FLOAT_LOG2 5L
34#define JS_BITS_PER_DOUBLE_LOG2 6L
35#define JS_BITS_PER_WORD_LOG2 5L
36
37#define JS_ALIGN_OF_SHORT 2L
38#define JS_ALIGN_OF_INT 4L
39#define JS_ALIGN_OF_LONG 4L
40#define JS_ALIGN_OF_INT64 8L
41#define JS_ALIGN_OF_FLOAT 4L
42#define JS_ALIGN_OF_DOUBLE 8L
43#define JS_ALIGN_OF_POINTER 4L
44#define JS_ALIGN_OF_WORD 4L
45
46#define JS_BYTES_PER_WORD_LOG2 2L
47#define JS_BYTES_PER_DWORD_LOG2 3L
48#define JS_WORDS_PER_DWORD_LOG2 1L
49
50#define JS_STACK_GROWTH_DIRECTION (-1)
51
52#define JS_HAVE_LONG_LONG
53
54#endif /* js_cpucfg___ */
diff --git a/meta/packages/mozilla-headless/mozilla-headless_hg.bb b/meta/packages/mozilla-headless/mozilla-headless_hg.bb
index e8351703c7..44a829c7a3 100644
--- a/meta/packages/mozilla-headless/mozilla-headless_hg.bb
+++ b/meta/packages/mozilla-headless/mozilla-headless_hg.bb
@@ -3,10 +3,12 @@ FIXEDREV = "f4348fd85697"
3 3
4SRC_URI = "hg://hg.mozilla.org/incubator;protocol=http;rev=${FIXEDREV};module=offscreen \ 4SRC_URI = "hg://hg.mozilla.org/incubator;protocol=http;rev=${FIXEDREV};module=offscreen \
5 file://configurefix.patch;patch=1 \ 5 file://configurefix.patch;patch=1 \
6 file://0001-Adds-initial-Gtk-clipboard-support-to-moz-headless.patch;patch=1 \
7 file://mozilla-jemalloc.patch;patch=1 \
6 file://jsautocfg.h \ 8 file://jsautocfg.h \
7 file://mozconfig" 9 file://mozconfig"
8PV = "0.0+hg-1.0+${FIXEDREV}" 10PV = "0.0+hg-1.0+${FIXEDREV}"
9PR = "r0" 11PR = "r1"
10 12
11S = "${WORKDIR}/offscreen" 13S = "${WORKDIR}/offscreen"
12 14
@@ -16,6 +18,14 @@ FILES_${PN} += "${libdir}/xulrunner-1.9.2a1pre"
16FILES_${PN}-dev += "${libdir}/xulrunner-devel-1.9.2a1pre" 18FILES_${PN}-dev += "${libdir}/xulrunner-devel-1.9.2a1pre"
17FILES_${PN}-dbg += "${libdir}/xulrunner-devel-1.9.2a1pre/sdk/lib/.debug" 19FILES_${PN}-dbg += "${libdir}/xulrunner-devel-1.9.2a1pre/sdk/lib/.debug"
18 20
21TARGET_CC_ARCH = ""
22
23CFLAGS = "${TARGET_CFLAGS}"
24TARGET_CFLAGS = "-Os -g -pipe -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m32 -march=core2 -msse3 -mtune=generic -mfpmath=sse -fasynchronous-unwind-tables"
25
26LDFLAGS = "${TARGET_LDFLAGS}"
27TARGET_LDFLAGS = "-Wl,-rpath,${libdir}/xulrunner-1.9.2a1pre"
28
19inherit autotools_stage mozilla 29inherit autotools_stage mozilla
20 30
21acpaths = "-I ${S}/build/autoconf " 31acpaths = "-I ${S}/build/autoconf "
@@ -41,8 +51,8 @@ do_install_append () {
41 echo ${libdir}/xulrunner-1.9.2a1pre/ > ${D}${sysconfdir}/ld.so.conf.d/mozilla-headless 51 echo ${libdir}/xulrunner-1.9.2a1pre/ > ${D}${sysconfdir}/ld.so.conf.d/mozilla-headless
42} 52}
43 53
44EXTRA_OECONF =+ "--enable-application=xulrunner --enable-default-toolkit=cairo-headless \ 54EXTRA_OECONF =+ "--enable-application=xulrunner --enable-default-toolkit=cairo-headless --with-pthreads \
45 --enable-pango --disable-optimize --disable-debug --disable-tests \ 55 --enable-pango --enable-optimize --disable-debug --disable-tests \
46 --disable-printing --disable-crashreporter --disable-accessibility \ 56 --disable-printing --disable-crashreporter --disable-accessibility \
47 --disable-javaxpcom --enable-plugins --enable-system-sqlite --disable-necko-wifi" 57 --disable-javaxpcom --enable-plugins --enable-system-sqlite --disable-necko-wifi"
48 58
@@ -55,5 +65,6 @@ do_stage_append () {
55 ln -fs ${STAGING_DIR_HOST}${layout_datadir}/xulrunner-1.9.2a1pre/unstable/ ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/idl 65 ln -fs ${STAGING_DIR_HOST}${layout_datadir}/xulrunner-1.9.2a1pre/unstable/ ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/idl
56 ln -fs ${STAGING_DIR_HOST}${layout_includedir}/xulrunner-1.9.2a1pre/unstable/ ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/include 66 ln -fs ${STAGING_DIR_HOST}${layout_includedir}/xulrunner-1.9.2a1pre/unstable/ ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/include
57 ln -fs ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/sdk/lib/ ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/lib 67 ln -fs ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/sdk/lib/ ${STAGING_DIR_HOST}${layout_libdir}/xulrunner-devel-1.9.2a1pre/lib
68 install -m 755 ${S}/dist/host/bin/host_xpidl ${STAGING_BINDIR_NATIVE}/xpidl
58} 69}
59 70
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2026-01-23 21:20:16 +0000