static void
drag_data_get_cb (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
guint info,
guint time,
gpointer user_data)
{
gint pos;
pos = gtk_entry_get_current_icon_drag_source (GTK_ENTRY (widget));
if (pos == GTK_ENTRY_ICON_PRIMARY)
{
#if 0
gint start, end;
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), &start, &end))
{
gchar *str;
str = gtk_editable_get_chars (GTK_EDITABLE (widget), start, end);
gtk_selection_data_set_text (data, str, -1);
g_free (str);
}
#else
gtk_selection_data_set_text (data, "XXX", -1);
#endif
}
}
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == TargetTypeText)
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == TargetTypeMarkup) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = String(gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length());
} else if (info == TargetTypeURIList) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length());
} else if (info == TargetTypeNetscapeURL && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GUniquePtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));
} else if (info == TargetTypeImage)
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
else if (info == TargetTypeSmartPaste)
gtk_selection_data_set_text(selectionData, "", -1);
else if (info == TargetTypeUnknown) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
auto types = dataObject->unknownTypes();
auto end = types.end();
for (auto it = types.begin(); it != end; ++it) {
GUniquePtr<gchar> dictItem(g_strdup_printf("{'%s', '%s'}", it->key.utf8().data(), it->value.utf8().data()));
g_variant_builder_add_parsed(&builder, dictItem.get());
}
GRefPtr<GVariant> variant = g_variant_builder_end(&builder);
GUniquePtr<gchar> serializedVariant(g_variant_print(variant.get(), TRUE));
gtk_selection_data_set(selectionData, unknownAtom, 1, reinterpret_cast<const guchar*>(serializedVariant.get()), strlen(serializedVariant.get()));
}
}
static gboolean
export_to_text (SeahorseKeyManagerStore *self,
GtkSelectionData *selection_data)
{
guchar *output;
gsize size;
gboolean ret;
guint count;
g_return_val_if_fail (self->priv->drag_objects, FALSE);
g_debug ("exporting to text");
count = seahorse_exportable_export_to_text_wait (self->priv->drag_objects,
&output, &size, &self->priv->drag_error);
/* TODO: Need to print status if only partially exported */
if (count > 0) {
g_debug ("setting selection text");
gtk_selection_data_set_text (selection_data, (gchar *)output, (gint)size);
ret = TRUE;
} else if (self->priv->drag_error) {
g_message ("error occurred on export: %s", self->priv->drag_error->message);
ret = FALSE;
} else {
g_message ("no objects exported");
ret = FALSE;
}
g_free (output);
return ret;
}
static void
icon_drag_data_get (GtkWidget *event_box,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time_,
GbWorkspacePaneGroup *group)
{
GbWorkspacePaneGroupPrivate *priv;
GbWorkspacePane *pane;
const gchar *uri;
gchar **uris;
g_return_if_fail(GTK_IS_EVENT_BOX(event_box));
g_return_if_fail(GB_IS_WORKSPACE_PANE_GROUP(group));
priv = group->priv;
if ((pane = gb_workspace_pane_group_get_current_pane(group))) {
if ((uri = gb_workspace_pane_get_uri(pane))) {
gtk_selection_data_set_text(selection_data, uri, -1);
uris = g_new0(gchar*, 2);
uris[0] = g_strdup(uri);
uris[1] = NULL;
gtk_selection_data_set_uris(selection_data, uris);
g_strfreev(uris);
}
}
static void dest_dnd_set_data(GtkWidget *view,
GdkDragContext *context, GtkSelectionData *selection_data,
guint info, guint time, gpointer data)
{
gchar *path = NULL;
GList *list = NULL;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return;
gtk_tree_model_get(model, &iter, 1, &path, -1);
if (!path) return;
list = g_list_append(list, path);
gchar **uris = uris_from_pathlist(list);
gboolean ret = gtk_selection_data_set_uris(selection_data, uris);
if (!ret)
{
char *str = g_strjoinv("\r\n", uris);
ret = gtk_selection_data_set_text(selection_data, str, -1);
g_free(str);
}
string_list_free(list);
}
static void
on_log_view_drag_data_get (GtkWidget *log_view,
GdkDragContext *drag_context,
GtkSelectionData *data,
guint info, guint time,
GitLogPane *self)
{
GtkTreeSelection *selection;
GtkTreeIter iter;
GitRevision *revision;
gchar *sha;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (log_view));
if (gtk_tree_selection_count_selected_rows (selection) > 0)
{
gtk_tree_selection_get_selected (selection, NULL, &iter);
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->log_model), &iter,
0, &revision, -1);
sha = git_revision_get_sha (revision);
gtk_selection_data_set_text (data, sha, -1);
g_object_unref (revision);
g_free (sha);
}
}
static void
selection_handler( GtkWidget *WXUNUSED(widget),
GtkSelectionData *selection_data,
guint WXUNUSED(info),
guint WXUNUSED(time),
gpointer WXUNUSED(data) )
{
if (!wxTheClipboard) return;
if (!wxTheClipboard->m_data) return;
wxDataObject *data = wxTheClipboard->m_data;
wxDataFormat format( selection_data->target );
#ifdef __WXDEBUG__
wxLogTrace(TRACE_CLIPBOARD,
_T("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s"),
format.GetId().c_str(),
wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(),
wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(),
wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str()
);
#endif
if (!data->IsSupportedFormat( format )) return;
int size = data->GetDataSize( format );
if (size == 0) return;
void *d = malloc(size);
// Text data will be in UTF8 in Unicode mode.
data->GetDataHere( selection_data->target, d );
#ifdef __WXGTK20__
// NB: GTK+ requires special treatment of UTF8_STRING data, the text
// would show as UTF-8 data interpreted as latin1 (?) in other
// GTK+ apps if we used gtk_selection_data_set()
if (format == wxDataFormat(wxDF_UNICODETEXT))
{
gtk_selection_data_set_text(
selection_data,
(const gchar*)d,
size-1 );
}
else
#endif
{
gtk_selection_data_set(
selection_data,
GDK_SELECTION_TYPE_STRING,
8*sizeof(gchar),
(unsigned char*) d,
size-1 );
}
free(d);
}
static void
clipboard_get_cb (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info,
gpointer user_data_or_owner)
{
ClipboardData *clipboard_data = user_data_or_owner;
GdkAtom targets[1];
int n_targets;
targets[0] = gtk_selection_data_get_target (selection_data);
n_targets = 1;
if (gtk_targets_include_uri (targets, n_targets)) {
gtk_selection_data_set_uris (selection_data, clipboard_data->uris);
}
else if (gtk_targets_include_text (targets, n_targets)) {
char *str;
gsize len;
str = clipboard_data_convert_to_text (clipboard_data, FALSE, &len);
gtk_selection_data_set_text (selection_data, str, len);
g_free (str);
}
else if (gtk_selection_data_get_target (selection_data) == GNOME_COPIED_FILES) {
char *str;
gsize len;
str = clipboard_data_convert_to_text (clipboard_data, TRUE, &len);
gtk_selection_data_set (selection_data, GNOME_COPIED_FILES, 8, (guchar *) str, len);
g_free (str);
}
}
/* Called when another application wants the contents of our selection */
static void selection_get(GtkClipboard *primary,
GtkSelectionData *selection_data,
guint info,
gpointer data)
{
gchar *text;
if (info == TARGET_URI_LIST)
text = icon_create_uri_list();
else
{
GList *next;
GString *str;
str = g_string_new(NULL);
for (next = icon_selection; next; next = next->next)
{
Icon *icon = (Icon *) next->data;
g_string_append(str, icon->path);
g_string_append_c(str, ' ');
}
text = str->str;
g_string_free(str, FALSE);
}
gtk_selection_data_set_text(selection_data, text, strlen(text));
}
void
image_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GdkPixbuf *pixbuf;
const gchar *name;
switch (info)
{
case TARGET_IMAGE:
pixbuf = get_image_pixbuf (GTK_IMAGE (data));
gtk_selection_data_set_pixbuf (selection_data, pixbuf);
g_object_unref (pixbuf);
break;
case TARGET_TEXT:
if (gtk_image_get_storage_type (GTK_IMAGE (data)) == GTK_IMAGE_ICON_NAME)
gtk_image_get_icon_name (GTK_IMAGE (data), &name, NULL);
else
name = "Boo!";
gtk_selection_data_set_text (selection_data, name, -1);
break;
default:
g_assert_not_reached ();
}
}
void remmina_rdp_cliprdr_request_data(GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, RemminaProtocolWidget* gp)
{
GdkAtom target;
gpointer data;
RDP_CB_DATA_REQUEST_EVENT* event;
rfContext* rfi = GET_DATA(gp);
target = gtk_selection_data_get_target(selection_data);
rfi->format = remmina_rdp_cliprdr_get_format_from_gdkatom(target);
rfi->clipboard_queue = g_async_queue_new();
/* Request Clipboard data of the server */
event = (RDP_CB_DATA_REQUEST_EVENT*)
freerdp_event_new(CliprdrChannel_Class, CliprdrChannel_DataRequest, NULL, NULL);
event->format = rfi->format;
freerdp_channels_send_event(rfi->instance->context->channels, (wMessage*) event);
data = g_async_queue_timeout_pop(rfi->clipboard_queue, 1000000);
if (data != NULL)
{
if (info == CB_FORMAT_PNG || info == CB_FORMAT_DIB || info == CB_FORMAT_JPEG)
{
gtk_selection_data_set_pixbuf(selection_data, data);
g_object_unref(data);
}
else
{
gtk_selection_data_set_text(selection_data, data, -1);
}
}
}
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == getIdForTargetType(TargetTypeText))
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == getIdForTargetType(TargetTypeMarkup)) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = (gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length() + 1);
} else if (info == getIdForTargetType(TargetTypeURIList)) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length() + 1);
} else if (info == getIdForTargetType(TargetTypeNetscapeURL) && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GOwnPtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()) + 1);
} else if (info == getIdForTargetType(TargetTypeImage))
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
}
static void set_text_data(GtkSelectionData *selection_data, jstring data)
{
const char *text_data = mainEnv->GetStringUTFChars(data, NULL);
guint ntext_data = strlen(text_data);
gtk_selection_data_set_text(selection_data, text_data, ntext_data);
mainEnv->ReleaseStringUTFChars(data, text_data);
}
static void clipboard_get_contents_cb(GtkClipboard *clipboard, GtkSelectionData *selection_data,
guint info, gpointer data) {
PasteboardSelectionData* clipboardData = reinterpret_cast<PasteboardSelectionData*>(data);
ASSERT(clipboardData);
if ((gint)info == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) {
gtk_selection_data_set(selection_data, selection_data->target, 8,
reinterpret_cast<const guchar*>(clipboardData->markup()),
g_utf8_strlen(clipboardData->markup(), -1));
} else
gtk_selection_data_set_text(selection_data, clipboardData->text(), -1);
}
static void fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == WEBKIT_WEB_VIEW_TARGET_INFO_TEXT)
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) {
GOwnPtr<gchar> markup(g_strdup(dataObject->markup().utf8().data()));
gtk_selection_data_set(selectionData, selectionData->target, 8,
reinterpret_cast<const guchar*>(markup.get()),
strlen(markup.get()));
}
}
static void
cb_browser_drag_data_get (GtkWidget * widget, GdkDragContext * dc,
GtkSelectionData * data, guint info, guint timestamp, gpointer user_data)
{
if (info == DATA_COMPOSITION_DND_TARGET_TEXT_PLAIN) {
gchar *full_paths = NULL;
full_paths = xfburn_directory_browser_get_selection (XFBURN_DIRECTORY_BROWSER (widget));
gtk_selection_data_set_text (data, full_paths, -1);
g_free (full_paths);
}
}
void
caja_get_clipboard_callback (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info,
gpointer user_data)
{
char **uris;
GList *l;
int i;
CajaClipboardInfo *clipboard_info;
GdkAtom target;
clipboard_info =
caja_clipboard_monitor_get_clipboard_info (caja_clipboard_monitor_get ());
target = gtk_selection_data_get_target (selection_data);
if (gtk_targets_include_uri (&target, 1))
{
uris = g_malloc ((g_list_length (clipboard_info->files) + 1) * sizeof (char *));
i = 0;
for (l = clipboard_info->files; l != NULL; l = l->next)
{
uris[i] = caja_file_get_uri (l->data);
i++;
}
uris[i] = NULL;
gtk_selection_data_set_uris (selection_data, uris);
g_strfreev (uris);
}
else if (gtk_targets_include_text (&target, 1))
{
char *str;
gsize len;
str = convert_file_list_to_string (clipboard_info, TRUE, &len);
gtk_selection_data_set_text (selection_data, str, len);
g_free (str);
}
else if (target == copied_files_atom)
{
char *str;
gsize len;
str = convert_file_list_to_string (clipboard_info, FALSE, &len);
gtk_selection_data_set (selection_data, copied_files_atom, 8, str, len);
g_free (str);
}
}
static void
karea_primary_get (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info,
gpointer owner)
{
if (kselected.d[0] || kselected.d[1])
{
gchar *string_utf = utf8_for_char (kselected);
gtk_selection_data_set_text (selection_data, string_utf, -1);
g_free (string_utf);
}
}
gboolean uri_selection_data_set_uris_from_filelist(GtkSelectionData *selection_data, GList *list)
{
gchar **uris = uris_from_filelist(list);
gboolean ret = gtk_selection_data_set_uris(selection_data, uris);
if (!ret)
{
char *str = g_strjoinv("\r\n", uris);
ret = gtk_selection_data_set_text(selection_data, str, -1);
g_free(str);
}
g_strfreev(uris);
return ret;
}
static void cm_tree_drag_data_get_cb(GtkWidget *widget, GdkDragContext *drag_context,
GtkSelectionData *data, guint info, guint ltime,
CookieManagerPage *cmp)
{
GtkTreeIter iter, iter_store;
GtkTreeSelection *selection;
GtkTreeModel *model;
GList *rows;
CookieManagerPagePrivate *priv = cmp->priv;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview));
rows = gtk_tree_selection_get_selected_rows(selection, &model);
if (cm_list_length(rows) != 1)
{
cm_free_selection_list(rows, (GFunc) gtk_tree_path_free);
return;
}
/* get iter */
gtk_tree_model_get_iter(model, &iter, (GtkTreePath*) (g_list_nth_data(rows, 0)));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &iter_store, &iter);
if (gtk_tree_store_iter_is_valid(priv->store, &iter_store))
{
SoupCookie *cookie;
gchar *name;
const gchar *text;
gtk_tree_model_get(model, &iter,
COOKIE_MANAGER_COL_NAME, &name,
COOKIE_MANAGER_COL_COOKIE, &cookie,
-1);
if (name != NULL)
{
GtkTreeIter parent;
/* get the name of the parent item which should be a domain item */
if (cookie != NULL && gtk_tree_model_iter_parent(model, &parent, &iter))
{
g_free(name);
gtk_tree_model_get(model, &parent, COOKIE_MANAGER_COL_NAME, &name, -1);
}
text = cm_skip_leading_dot(name);
gtk_selection_data_set_text(data, text, -1);
}
g_free(name);
}
}
static void
_get_clipboard_callback (GtkClipboard* clipboard,
GtkSelectionData* selection_data,
guint info,
gpointer user_data)
{
g_debug ("_get_clipboard_callback: begin");
GdkAtom target;
target = gtk_selection_data_get_target (selection_data);
// set to a URI string
if (gtk_targets_include_uri (&target, 1))
{
char **uris;
uris = g_malloc ((clipboard_info.num + 1) * sizeof (char *));
int i = 0;
for (i = 0; i < clipboard_info.num; i++)
{
uris[i] = g_file_get_uri (clipboard_info.file_list[i]);
i++;
}
uris[i] = NULL;
gtk_selection_data_set_uris (selection_data, uris);
g_strfreev (uris);
}
// set to a UTF-8 encoded string
else if (gtk_targets_include_text (&target, 1))
{
char *str;
gsize len;
str = __convert_file_list_to_string (&clipboard_info, TRUE, &len);
gtk_selection_data_set_text (selection_data, str, len);
g_free (str);
}
//NOTE: cut or copy
else if (target == copied_files_atom)
{
char *str;
gsize len;
str = __convert_file_list_to_string (&clipboard_info, FALSE, &len);
gtk_selection_data_set (selection_data, copied_files_atom, 8, (const guchar*)str, len);
g_free (str);
}
g_debug ("_get_clipboard_callback: end");
}
static void clip_get ( GtkClipboard *c, GtkSelectionData *selection_data, guint info, gpointer p )
{
vik_clipboard_t *vc = p;
if ( info == 0 ) {
// Viking Data Type
// g_print("clip_get: vc = %p, size = %d\n", vc, sizeof(*vc) + vc->len);
gtk_selection_data_set ( selection_data, selection_data->target, 8, (void *)vc, sizeof(*vc) + vc->len );
}
if ( info == 1 ) {
// Should be a string, but make sure it's something
if ( vc->text )
gtk_selection_data_set_text ( selection_data, vc->text, -1); // string text is null terminated
}
}
static void clipboard_get_contents_cb(GtkClipboard* clipboard, GtkSelectionData* selection_data, guint info, gpointer data)
{
WebKitWebView* webView = reinterpret_cast<WebKitWebView*>(data);
Frame* frame = core(webView)->focusController()->focusedOrMainFrame();
PassRefPtr<Range> selectedRange = frame->selection()->toNormalizedRange();
if (static_cast<gint>(info) == WEBKIT_WEB_VIEW_TARGET_INFO_HTML) {
String markup = createMarkup(selectedRange.get(), 0, AnnotateForInterchange);
gtk_selection_data_set(selection_data, selection_data->target, 8,
reinterpret_cast<const guchar*>(markup.utf8().data()), markup.utf8().length());
} else {
String text = selectedRange->text();
gtk_selection_data_set_text(selection_data, text.utf8().data(), text.utf8().length());
}
}
//!
//! @brief To be written
//!
static void _kanjipadwindow_primary_candidates_get (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer data)
{
GwKanjipadWindow *window;
GwKanjipadWindowPrivate *priv;
gchar *string_utf;
window = GW_KANJIPADWINDOW (data);
priv = window->priv;
if (priv->kselected[0] || priv->kselected[1])
{
string_utf = _kanjipadwindow_utf8_for_char (priv->kselected);
gtk_selection_data_set_text (selection_data, string_utf, -1);
g_free (string_utf);
}
}
/* sets the picked character as the selection when it gets a request */
static void
charpick_selection_handler(GtkWidget *widget,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
charpick_data *p_curr_data = data;
gint num;
gchar tmp[7];
num = g_unichar_to_utf8 (p_curr_data->selected_unichar, tmp);
tmp[num] = '\0';
gtk_selection_data_set_text (selection_data, tmp, -1);
return;
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkSelectionData_gtk_1selection_1data_1set_1text
(
JNIEnv* env,
jclass cls,
jlong _self,
jstring _str,
jint _len
)
{
gboolean result;
jboolean _result;
GtkSelectionData* self;
const gchar* str;
gint len;
// convert parameter self
self = (GtkSelectionData*) _self;
// convert parameter str
str = (const gchar*) bindings_java_getString(env, _str);
if (str == NULL) {
return JNI_FALSE; // Java Exception already thrown
}
// convert parameter len
len = (gint) _len;
// call function
result = gtk_selection_data_set_text(self, str, len);
// cleanup parameter self
// cleanup parameter str
bindings_java_releaseString(str);
// cleanup parameter len
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
static void
gstyle_color_widget_on_drag_data_get (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *data,
guint info,
guint time)
{
GstyleColorWidget *self = (GstyleColorWidget *)widget;
GdkAtom target = gtk_selection_data_get_target (data);
GstyleColor *color;
guint16 data_rgba[4];
GdkRGBA rgba;
g_assert (GSTYLE_IS_COLOR_WIDGET (self));
g_assert (GDK_IS_DRAG_CONTEXT (context));
if (self->filter_func != NULL && GSTYLE_IS_COLOR (self->filtered_color))
color = self->filtered_color;
else
color = self->color;
if (target == gdk_atom_intern_static_string ("GSTYLE_COLOR_WIDGET"))
gtk_selection_data_set (data, target, 8, (void*)&color, sizeof (gpointer));
else if (target == gdk_atom_intern_static_string ("application/x-color"))
{
gstyle_color_fill_rgba (color, &rgba);
data_rgba[0] = (guint16) (rgba.red * 65535);
data_rgba[1] = (guint16) (rgba.green * 65535);
data_rgba[2] = (guint16) (rgba.blue * 65535);
data_rgba[3] = (guint16) (rgba.alpha * 65535);
gtk_selection_data_set (data, target, 16, (void*)&data_rgba, 8);
}
else if (gtk_targets_include_text (&target, 1))
{
g_autofree gchar *name = NULL;
name = gstyle_color_to_string (color, GSTYLE_COLOR_KIND_ORIGINAL);
if (name == NULL)
name = gstyle_color_to_string (color, GSTYLE_COLOR_KIND_RGB_HEX6);
gtk_selection_data_set_text (data, name, -1);
}
}
static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context,
GtkSelectionData *selection_data, guint info,
guint time, gpointer data)
{
ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
switch (info)
{
case TARGET_APP_EXIF_ENTRY:
gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
8, (gpointer) &entry, sizeof(entry));
break;
case TARGET_TEXT_PLAIN:
default:
gtk_selection_data_set_text(selection_data, ee->key, -1);
break;
}
}
void callback_clipboard_get(GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info, gpointer user_data)
{
struct XojSelectionData *sel = (struct XojSelectionData *)user_data;
switch (info) {
case TARGET_XOURNAL:
gtk_selection_data_set(selection_data,
gdk_atom_intern(XOURNAL_TARGET_ATOM, FALSE), 8, sel->xo_data, sel->xo_data_len);
break;
case TARGET_TEXT:
if (sel->text_data!=NULL)
gtk_selection_data_set_text(selection_data, sel->text_data, -1);
break;
case TARGET_PIXBUF:
if (sel->image_data!=NULL)
gtk_selection_data_set_pixbuf(selection_data, sel->image_data);
break;
}
}
static void gretl_clipboard_get (GtkClipboard *clip,
GtkSelectionData *selection_data,
guint info,
gpointer p)
{
#if 1 || CLIPDEBUG
fprintf(stderr, "gretl_clipboard_get: info = %d (%s)\n",
(int) info, fmt_label(info));
#endif
if (image_type(info)) {
write_plot_for_copy(info);
if (clipboard_buf == NULL) {
return;
}
} else {
if (clipboard_buf == NULL || *clipboard_buf == '\0') {
return;
} else if (info != TARGET_UTF8_STRING) {
/* remove any Unicode minuses (??) */
strip_unicode_minus(clipboard_buf);
}
}
if (info == TARGET_RTF) {
gtk_selection_data_set(selection_data,
GDK_SELECTION_TYPE_STRING,
8, (guchar *) clipboard_buf,
strlen(clipboard_buf));
} else if (image_type(info)) {
gtk_selection_data_set(selection_data,
GDK_SELECTION_TYPE_STRING,
8, (guchar *) clipboard_buf,
clipboard_bytes);
} else {
gtk_selection_data_set_text(selection_data, clipboard_buf, -1);
}
}
