static void set_data(GdkAtom target, GtkSelectionData *selection_data, jobject data)
{
gchar *name = gdk_atom_name(target);
jstring typeString;
jobject result;
if (gtk_targets_include_text(&target, 1)) {
typeString = mainEnv->NewStringUTF("text/plain");
result = mainEnv->CallObjectMethod(data, jMapGet, typeString, NULL);
if (!EXCEPTION_OCCURED(mainEnv) && result != NULL) {
set_text_data(selection_data, (jstring)result);
}
} else if (gtk_targets_include_image(&target, 1, TRUE)) {
typeString = mainEnv->NewStringUTF("application/x-java-rawimage");
result = mainEnv->CallObjectMethod(data, jMapGet, typeString, NULL);
if (!EXCEPTION_OCCURED(mainEnv) && result != NULL) {
set_image_data(selection_data, result);
}
} else if (target == MIME_TEXT_URI_LIST_TARGET) {
set_uri_data(selection_data, data);
} else {
typeString = mainEnv->NewStringUTF(name);
result = mainEnv->CallObjectMethod(data, jMapGet, typeString, NULL);
if (!EXCEPTION_OCCURED(mainEnv) && result != NULL) {
if (mainEnv->IsInstanceOf(result, jStringCls)) {
set_jstring_data(selection_data, target, (jstring)result);
} else if (mainEnv->IsInstanceOf(result, jByteBufferCls)) {
set_bytebuffer_data(selection_data, target, result);
}
}
}
g_free(name);
}
static VALUE
targets_include_image(VALUE self, VALUE rbtargets, VALUE rbwritable)
{
gboolean writable = RVAL2CBOOL(rbwritable);
long n;
GdkAtom *targets = RVAL2GDKATOMS(rbtargets, &n);
gboolean result;
result = gtk_targets_include_image(targets, n, writable);
g_free(targets);
return result;
}
/**
* gtk_selection_data_targets_include_image:
* @selection_data: a #GtkSelectionData object
* @writable: whether to accept only targets for which GTK+ knows
* how to convert a pixbuf into the format
*
* Given a #GtkSelectionData object holding a list of targets,
* determines if any of the targets in @targets can be used to
* provide a #GdkPixbuf.
*
* Returns: %TRUE if @selection_data holds a list of targets,
* and a suitable target for images is included, otherwise %FALSE.
**/
gboolean
gtk_selection_data_targets_include_image (const GtkSelectionData *selection_data,
gboolean writable)
{
GdkAtom *targets;
gint n_targets;
gboolean result = FALSE;
g_return_val_if_fail (selection_data != NULL, FALSE);
init_atoms ();
if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets))
{
result = gtk_targets_include_image (targets, n_targets, writable);
g_free (targets);
}
return result;
}
/*
* Class: com_sun_glass_ui_gtk_GtkSystemClipboard
* Method: mimesFromSystem
* Signature: ()[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_com_sun_glass_ui_gtk_GtkSystemClipboard_mimesFromSystem
(JNIEnv * env, jobject obj)
{
GdkAtom *targets;
gint ntargets;
gint i;
GdkAtom *convertible;
GdkAtom *convertible_ptr;
gchar *name;
jobjectArray result;
jstring tmpString;
init_atoms();
gtk_clipboard_wait_for_targets(get_clipboard(), &targets, &ntargets);
convertible = (GdkAtom*) glass_try_malloc0_n(ntargets * 2, sizeof(GdkAtom)); //theoretically, the number can double
if (!convertible) {
if (ntargets > 0) {
glass_throw_oom(env, "Failed to allocate mimes");
}
g_free(targets);
return NULL;
}
convertible_ptr = convertible;
bool uri_list_added = false;
bool text_added = false;
bool image_added = false;
for (i = 0; i < ntargets; ++i) {
//handle text targets
//if (targets[i] == TEXT_TARGET || targets[i] == STRING_TARGET || targets[i] == UTF8_STRING_TARGET) {
if (gtk_targets_include_text(targets + i, 1) && !text_added) {
*(convertible_ptr++) = MIME_TEXT_PLAIN_TARGET;
text_added = true;
} else if (gtk_targets_include_image(targets + i, 1, TRUE) && !image_added) {
*(convertible_ptr++) = MIME_JAVA_IMAGE;
image_added = true;
}
//TODO text/x-moz-url ? RT-17802
if (targets[i] == MIME_TEXT_URI_LIST_TARGET) {
if (uri_list_added) {
continue;
}
gchar** uris = gtk_clipboard_wait_for_uris(get_clipboard());
if (uris) {
guint size = g_strv_length(uris);
guint files_cnt = get_files_count(uris);
if (files_cnt) {
*(convertible_ptr++) = MIME_FILES_TARGET;
}
if (size - files_cnt) {
*(convertible_ptr++) = MIME_TEXT_URI_LIST_TARGET;
}
g_strfreev(uris);
}
uri_list_added = true;
} else {
*(convertible_ptr++) = targets[i];
}
}
result = env->NewObjectArray(convertible_ptr - convertible, jStringCls, NULL);
for (i = 0; convertible + i < convertible_ptr; ++i) {
name = gdk_atom_name(convertible[i]);
tmpString = env->NewStringUTF(name);
env->SetObjectArrayElement(result, (jsize)i, tmpString);
g_free(name);
}
g_free(targets);
g_free(convertible);
return result;
}
void
nsClipboard::SelectionGetEvent(GtkClipboard *aClipboard,
GtkSelectionData *aSelectionData)
{
// 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);
if (!trans) {
// We have nothing to serve
#ifdef DEBUG_CLIPBOARD
printf("nsClipboard::SelectionGetEvent() - %s clipboard is empty!\n",
whichClipboard == kSelectionClipboard ? "Selection" : "Global");
#endif
return;
}
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;
}
// Check to see if the selection data is an image type
if (gtk_targets_include_image(&aSelectionData->target, 1, TRUE)) {
// Look through our transfer data for the image
static const char* const imageMimeTypes[] = {
kNativeImageMime, kPNGImageMime, kJPEGImageMime, kGIFImageMime };
nsCOMPtr<nsISupports> item;
PRUint32 len;
nsCOMPtr<nsISupportsInterfacePointer> ptrPrimitive;
for (PRUint32 i = 0; !ptrPrimitive && i < NS_ARRAY_LENGTH(imageMimeTypes); i++) {
rv = trans->GetTransferData(imageMimeTypes[i], getter_AddRefs(item), &len);
ptrPrimitive = do_QueryInterface(item);
}
if (!ptrPrimitive)
return;
nsCOMPtr<nsISupports> primitiveData;
ptrPrimitive->GetData(getter_AddRefs(primitiveData));
nsCOMPtr<imgIContainer> image(do_QueryInterface(primitiveData));
if (!image) // Not getting an image for an image mime type!?
return;
GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(image);
if (!pixbuf)
return;
gtk_selection_data_set_pixbuf(aSelectionData, pixbuf);
g_object_unref(pixbuf);
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);
}
