GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObject, SmartPasteInclusion shouldInludeSmartPaste)
{
GtkTargetList* list = gtk_target_list_new(nullptr, 0);
if (dataObject->hasText())
gtk_target_list_add_text_targets(list, TargetTypeText);
if (dataObject->hasMarkup())
gtk_target_list_add(list, markupAtom, 0, TargetTypeMarkup);
if (dataObject->hasURIList()) {
gtk_target_list_add_uri_targets(list, TargetTypeURIList);
gtk_target_list_add(list, netscapeURLAtom, 0, TargetTypeNetscapeURL);
}
if (dataObject->hasImage())
gtk_target_list_add_image_targets(list, TargetTypeImage, TRUE);
if (dataObject->hasUnknownTypeData())
gtk_target_list_add(list, unknownAtom, 0, TargetTypeUnknown);
if (shouldInludeSmartPaste == IncludeSmartPaste)
gtk_target_list_add(list, smartPasteAtom, 0, TargetTypeSmartPaste);
return list;
}
void PasteboardHelper::initializeTargetList()
{
gtk_target_list_add_text_targets(m_targetList, getIdForTargetType(TargetTypeText));
gtk_target_list_add(m_targetList, markupAtom, 0, getIdForTargetType(TargetTypeMarkup));
gtk_target_list_add_uri_targets(m_targetList, getIdForTargetType(TargetTypeURIList));
gtk_target_list_add(m_targetList, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL));
gtk_target_list_add_image_targets(m_targetList, getIdForTargetType(TargetTypeImage), TRUE);
}
static void add_target_from_jstring(JNIEnv *env, GtkTargetList *list, jstring string)
{
const char *gstring = env->GetStringUTFChars(string, NULL);
if (g_strcmp0(gstring, "text/plain") == 0) {
gtk_target_list_add_text_targets(list, 0);
} else if (g_strcmp0(gstring, "application/x-java-rawimage") == 0) {
gtk_target_list_add_image_targets(list, 0, TRUE);
} else if (g_strcmp0(gstring, "application/x-java-file-list") == 0) {
gtk_target_list_add(list, MIME_TEXT_URI_LIST_TARGET, 0, 0);
} else {
gtk_target_list_add(list, gdk_atom_intern(gstring, FALSE), 0, 0);
}
env->ReleaseStringUTFChars(string, gstring);
}
static void
_g_paste_clipboard_select_uris (GPasteClipboard *self,
GPasteUrisItem *item)
{
g_return_if_fail (G_PASTE_IS_CLIPBOARD (self));
g_return_if_fail (G_PASTE_IS_URIS_ITEM (item));
GtkClipboard *real = self->priv->real;
GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
_g_paste_clipboard_set_text (self, g_paste_item_get_value (G_PASTE_ITEM (item)));
gtk_target_list_add_text_targets (target_list, 0);
gtk_target_list_add_uri_targets (target_list, 0);
gtk_target_list_add (target_list, g_paste_clipboard_copy_files_target, 0, 0);
gint n_targets;
GtkTargetEntry *targets = gtk_target_table_new_from_list (target_list, &n_targets);
gtk_clipboard_set_with_owner (real,
targets,
n_targets,
g_paste_clipboard_get_clipboard_data,
g_paste_clipboard_clear_clipboard_data,
g_object_ref (item));
gtk_clipboard_store (real);
gtk_target_table_free (targets, n_targets);
gtk_target_list_unref (target_list);
}
/*
* main entry point for cut and copy operations
* cut : cut = TRUE;
* copy: cut = FALSE;
*
* NOTE: every we cut or copy, we need to override
* previous data in clipboard.so we acquire
* clipboard every time we cut or copy.
* _clipboard_owner_change_cb is used to clear
* clipboard
* 1. this is the only way we can set clipboard_info.
* 2. this is the only way we can set clipboard_info_prev.
*
*/
void
init_fileops_clipboard (GFile* file_list[], guint num, gboolean cut)
{
g_debug ("init_fileops_clipboard:begin");
//set prev clipboard_info
__clear_clipboard_info (&clipboard_info_prev);
__copy_clipboard_info (&clipboard_info, &clipboard_info_prev);
int j=0;
for (j = 0; j < clipboard_info_prev.num; j++)
{
g_debug ("init_fileops prev: file_list[%d] = %s", j, g_file_get_uri (clipboard_info_prev.file_list[j]));
}
//we're the clipboard owner, cleanup clipboard_info
__clear_clipboard_info (&clipboard_info);
clipboard_info.file_list = (GFile**)g_malloc (num * sizeof (GFile*));
int i;
for (i = 0; i < num; i++)
{
clipboard_info.file_list[i] = g_object_ref (file_list[i]);
g_debug ("init_fileops %s: file_list[%d] = %s", cut? "cut": "paste", i, g_file_get_uri (file_list[i]));
}
clipboard_info.num = num;
clipboard_info.cut = cut;
GtkTargetList* target_list;
GtkTargetEntry* targets;
gint n_targets;
if (copied_files_atom == GDK_NONE)
copied_files_atom = gdk_atom_intern ("x-special/gnome-copied-files", FALSE);
//TODO: request clipboard data before take ownership
// so we can interoperate with nautilus.
if (fileops_clipboard == NULL)
{
fileops_clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
g_signal_connect (fileops_clipboard, "owner-change",
G_CALLBACK (_clipboard_owner_change_cb), NULL);
}
target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add (target_list, copied_files_atom, 0, 0);
gtk_target_list_add_uri_targets (target_list, 0);
gtk_target_list_add_text_targets (target_list, 0);
targets = gtk_target_table_new_from_list (target_list, &n_targets);
gtk_clipboard_set_with_data (fileops_clipboard,
targets, n_targets,
_get_clipboard_callback, _clear_clipboard_callback,
NULL);
gtk_target_list_unref (target_list);
gtk_target_table_free (targets, n_targets);
g_debug ("init_fileops_clipboard:end");
}
static GtkTargetList *
gnm_soi_get_target_list (SheetObject const *so)
{
SheetObjectImage *soi = SHEET_OBJECT_IMAGE (so);
GtkTargetList *tl = gtk_target_list_new (NULL, 0);
char *mime_str = go_image_format_to_mime (soi->type);
GSList *mimes, *ptr;
GdkPixbuf *pixbuf;
mimes = go_strsplit_to_slist (mime_str, ',');
for (ptr = mimes; ptr != NULL; ptr = ptr->next) {
const char *mime = ptr->data;
if (mime != NULL && *mime != '\0')
gtk_target_list_add (tl, gdk_atom_intern (mime, FALSE),
0, 0);
}
g_free (mime_str);
go_slist_free_custom (mimes, g_free);
/* No need to eliminate duplicates. */
if ((pixbuf = soi_get_pixbuf (soi, 1.0)) != NULL) {
gtk_target_list_add_image_targets (tl, 0, TRUE);
g_object_unref (pixbuf);
}
return tl;
}
static void test_pasting_markup(CopyAndPasteFixture* fixture, gconstpointer data)
{
fixture->info = (TestInfo*)data;
currentFixture = fixture;
GtkTargetList* targetList = gtk_target_list_new(0, 0);
gtk_target_list_add(targetList, gdk_atom_intern("text/html", FALSE), 0, 0);
int numberOfTargets = 1;
GtkTargetEntry* targetTable = gtk_target_table_new_from_list(targetList, &numberOfTargets);
gtk_clipboard_set_with_data(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
targetTable, numberOfTargets,
pasting_test_get_data_callback,
pasting_test_clear_data_callback,
g_strdup(fixture->info->expectedContent));
gtk_target_list_unref(targetList);
gtk_target_table_free(targetTable, numberOfTargets);
g_signal_connect(fixture->window, "map-event",
G_CALLBACK(map_event_cb), fixture);
g_signal_connect(fixture->webView, "window-object-cleared",
G_CALLBACK(window_object_cleared_callback), fixture);
gtk_widget_show(fixture->window);
gtk_widget_show(GTK_WIDGET(fixture->webView));
gtk_window_present(GTK_WINDOW(fixture->window));
g_main_loop_run(fixture->loop);
}
static VALUE
rg_add(VALUE self, VALUE target, VALUE flags, VALUE info)
{
gtk_target_list_add(_SELF(self), RVAL2ATOM(target),
FIX2UINT(flags), FIX2UINT(info));
return self;
}
PasteboardHelper::PasteboardHelper()
: m_targetList(adoptGRef(gtk_target_list_new(nullptr, 0)))
{
textPlainAtom = gdk_atom_intern_static_string("text/plain;charset=utf-8");
markupAtom = gdk_atom_intern_static_string("text/html");
netscapeURLAtom = gdk_atom_intern_static_string("_NETSCAPE_URL");
uriListAtom = gdk_atom_intern_static_string("text/uri-list");
smartPasteAtom = gdk_atom_intern_static_string("application/vnd.webkitgtk.smartpaste");
unknownAtom = gdk_atom_intern_static_string("application/vnd.webkitgtk.unknown");
gtk_target_list_add_text_targets(m_targetList.get(), PasteboardHelper::TargetTypeText);
gtk_target_list_add(m_targetList.get(), markupAtom, 0, PasteboardHelper::TargetTypeMarkup);
gtk_target_list_add_uri_targets(m_targetList.get(), PasteboardHelper::TargetTypeURIList);
gtk_target_list_add(m_targetList.get(), netscapeURLAtom, 0, PasteboardHelper::TargetTypeNetscapeURL);
gtk_target_list_add_image_targets(m_targetList.get(), PasteboardHelper::TargetTypeImage, TRUE);
gtk_target_list_add(m_targetList.get(), unknownAtom, 0, PasteboardHelper::TargetTypeUnknown);
}
void DragClient::startDrag(DragImageRef image, const IntPoint& dragImageOrigin, const IntPoint& eventPos, Clipboard*, Frame* frame, bool linkDrag)
{
Element* targetElement = frame->document()->elementFromPoint(m_startPos.x(), m_startPos.y());
bool imageDrag = false;
if (targetElement)
imageDrag = targetElement->renderer()->isImage();
GdkAtom textHtml = gdk_atom_intern_static_string("text/html");
GdkAtom netscapeUrl = gdk_atom_intern_static_string("_NETSCAPE_URL");
GtkTargetList* targetList = gtk_target_list_new(NULL, 0);
gtk_target_list_add(targetList, textHtml, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML);
gtk_target_list_add_text_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT);
if (linkDrag || imageDrag) {
gtk_target_list_add(targetList, netscapeUrl, 0, WEBKIT_WEB_VIEW_TARGET_INFO_NETSCAPE_URL);
gtk_target_list_add_uri_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_URI_LIST);
}
if (imageDrag)
gtk_target_list_add_image_targets(targetList, WEBKIT_WEB_VIEW_TARGET_INFO_IMAGE, false);
GdkDragAction dragAction = GDK_ACTION_COPY;
if (linkDrag) {
dragAction = GDK_ACTION_LINK;
if (imageDrag)
dragAction = (GdkDragAction)(dragAction | GDK_ACTION_COPY);
}
GdkEvent* event = gdk_event_new(GDK_BUTTON_PRESS);
reinterpret_cast<GdkEventButton*>(event)->window = gtk_widget_get_window(GTK_WIDGET(m_webView));
reinterpret_cast<GdkEventButton*>(event)->time = GDK_CURRENT_TIME;
GdkDragContext* context = gtk_drag_begin(GTK_WIDGET(m_webView),
targetList, dragAction, 1, event);
g_object_ref(context);
if (image)
gtk_drag_set_icon_pixbuf(context, image, eventPos.x() - dragImageOrigin.x(), eventPos.y() - dragImageOrigin.y());
else
gtk_drag_set_icon_default(context);
gtk_target_list_unref(targetList);
}
GtkTargetList* PasteboardHelper::targetListForDataObject(DataObjectGtk* dataObject)
{
GtkTargetList* list = gtk_target_list_new(0, 0);
if (dataObject->hasText())
gtk_target_list_add_text_targets(list, getIdForTargetType(TargetTypeText));
if (dataObject->hasMarkup())
gtk_target_list_add(list, markupAtom, 0, getIdForTargetType(TargetTypeMarkup));
if (dataObject->hasURIList()) {
gtk_target_list_add_uri_targets(list, getIdForTargetType(TargetTypeURIList));
gtk_target_list_add(list, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL));
}
if (dataObject->hasImage())
gtk_target_list_add_image_targets(list, getIdForTargetType(TargetTypeImage), TRUE);
return list;
}
void remmina_rdp_cliprdr_process_format_list(RemminaProtocolWidget* gp, RDP_CB_FORMAT_LIST_EVENT* event)
{
RemminaPluginRdpUiObject* ui;
int i;
GtkTargetList* list = gtk_target_list_new (NULL, 0);
for (i = 0; i < event->num_formats; i++)
{
if (event->formats[i] == CB_FORMAT_UNICODETEXT)
{
GdkAtom atom = gdk_atom_intern("UTF8_STRING", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_UNICODETEXT);
}
if (event->formats[i] == CB_FORMAT_TEXT)
{
GdkAtom atom = gdk_atom_intern("TEXT", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_TEXT);
}
if (event->formats[i] == CB_FORMAT_DIB)
{
GdkAtom atom = gdk_atom_intern("image/bmp", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_DIB);
}
if (event->formats[i] == CB_FORMAT_JPEG)
{
GdkAtom atom = gdk_atom_intern("image/jpeg", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_JPEG);
}
if (event->formats[i] == CB_FORMAT_PNG)
{
GdkAtom atom = gdk_atom_intern("image/png", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_PNG);
}
}
ui = g_new0(RemminaPluginRdpUiObject, 1);
ui->type = REMMINA_RDP_UI_CLIPBOARD;
ui->clipboard.type = REMMINA_RDP_UI_CLIPBOARD_SET_DATA;
ui->clipboard.targetlist = list;
rf_queue_ui(gp, ui);
}
static GtkTargetList* targetListForDataObject(DataObjectGtk* dataObject)
{
GtkTargetList* list = gtk_target_list_new(0, 0);
if (dataObject->hasText())
gtk_target_list_add_text_targets(list, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT);
if (dataObject->hasMarkup())
gtk_target_list_add(list, gdkMarkupAtom, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML);
return list;
}
/**
* gtk_target_table_make:
* @format_atom: format atom for the target list
* @n_targets: out variable for the size of the table
*
* Generate the target table for pasting to clipboard. Use
* gtk_target_table_free (targets, n_targets);
*
* Returns: the table and the size in the out variable @n_targets
*/
GtkTargetEntry *
gtk_target_table_make (GdkAtom format_atom, gint * n_targets)
{
GtkTargetList *list;
GtkTargetEntry *targets;
list = gtk_target_list_new (NULL, 0);
gtk_target_list_add (list, format_atom, 0, 0);
#if USE_DEBUG
// this allows to paste into a text editor
gtk_target_list_add (list, gdk_atom_intern_static_string ("UTF8_STRING"), 0,
1);
gtk_target_list_add (list, gdk_atom_intern_static_string ("TEXT"), 0, 2);
gtk_target_list_add (list, gdk_atom_intern_static_string ("text/plain"), 0,
3);
gtk_target_list_add (list,
gdk_atom_intern_static_string ("text/plain;charset=utf-8"), 0, 4);
#endif
targets = gtk_target_table_new_from_list (list, n_targets);
gtk_target_list_unref (list);
return targets;
}
static void
_gth_browser_clipboard_copy_or_cut (GthBrowser *browser,
GList *file_list,
gboolean cut)
{
ClipboardData *data;
GtkTargetList *target_list;
GtkTargetEntry *targets;
int n_targets;
GList *scan;
int i;
data = g_new0 (ClipboardData, 1);
data->cut = cut;
data->n_uris = g_list_length (file_list);
data->uris = g_new (char *, data->n_uris + 1);
for (scan = file_list, i = 0; scan; scan = scan->next, i++) {
GthFileData *file_data = scan->data;
data->uris[i] = g_file_get_uri (file_data->file);
}
data->uris[data->n_uris] = NULL;
target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add (target_list, GNOME_COPIED_FILES, 0, 0);
gtk_target_list_add_uri_targets (target_list, 0);
gtk_target_list_add_text_targets (target_list, 0);
targets = gtk_target_table_new_from_list (target_list, &n_targets);
gtk_clipboard_set_with_data (gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (browser)), GDK_SELECTION_CLIPBOARD),
targets,
n_targets,
clipboard_get_cb,
clipboard_clear_cb,
data);
gtk_target_list_unref (target_list);
gtk_target_table_free (targets, n_targets);
}
static void
configure_drag_dest (EggEditableToolbar *etoolbar,
GtkToolbar *toolbar)
{
EggToolbarsItemType *type;
GtkTargetList *targets;
GList *list;
/* Make every toolbar able to receive drag-drops. */
gtk_drag_dest_set (GTK_WIDGET (toolbar), 0,
dest_drag_types, G_N_ELEMENTS (dest_drag_types),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
/* Add any specialist drag-drop abilities. */
targets = gtk_drag_dest_get_target_list (GTK_WIDGET (toolbar));
list = egg_toolbars_model_get_types (etoolbar->priv->model);
while (list)
{
type = list->data;
if (type->new_name != NULL || type->get_name != NULL)
gtk_target_list_add (targets, type->type, 0, 0);
list = list->next;
}
}
static GtkTargetList* gtkCreateTargetList(const char* value)
{
GtkTargetList* targetlist = gtk_target_list_new((GtkTargetEntry*)NULL, 0);
char valueCopy[256];
char valueTemp[256];
int info = 0;
sprintf(valueCopy, "%s", value);
while(iupStrToStrStr(valueCopy, valueTemp, valueCopy, ',') > 0)
{
gtk_target_list_add(targetlist, gdk_atom_intern(valueTemp, 0), 0, info++);
if(iupStrEqualNoCase(valueCopy, valueTemp))
break;
}
if (targetlist->ref_count == 0)
{
gtk_target_list_unref(targetlist);
return NULL;
}
return targetlist;
}
NS_IMETHODIMP
nsClipboard::SetData(nsITransferable *aTransferable,
nsIClipboardOwner *aOwner, PRInt32 aWhichClipboard)
{
// See if we can short cut
if ((aWhichClipboard == kGlobalClipboard &&
aTransferable == mGlobalTransferable.get() &&
aOwner == mGlobalOwner.get()) ||
(aWhichClipboard == kSelectionClipboard &&
aTransferable == mSelectionTransferable.get() &&
aOwner == mSelectionOwner.get())) {
return NS_OK;
}
nsresult rv;
if (!mPrivacyHandler) {
rv = NS_NewClipboardPrivacyHandler(getter_AddRefs(mPrivacyHandler));
NS_ENSURE_SUCCESS(rv, rv);
}
rv = mPrivacyHandler->PrepareDataForClipboard(aTransferable);
NS_ENSURE_SUCCESS(rv, rv);
// Clear out the clipboard in order to set the new data
EmptyClipboard(aWhichClipboard);
// List of suported targets
GtkTargetList *list = gtk_target_list_new(NULL, 0);
// Get the types of supported flavors
nsCOMPtr<nsISupportsArray> flavors;
rv = aTransferable->FlavorsTransferableCanExport(getter_AddRefs(flavors));
if (!flavors || NS_FAILED(rv))
return NS_ERROR_FAILURE;
// Add all the flavors to this widget's supported type.
PRBool imagesAdded = PR_FALSE;
PRUint32 count;
flavors->Count(&count);
for (PRUint32 i=0; i < count; i++) {
nsCOMPtr<nsISupports> tastesLike;
flavors->GetElementAt(i, getter_AddRefs(tastesLike));
nsCOMPtr<nsISupportsCString> flavor = do_QueryInterface(tastesLike);
if (flavor) {
nsXPIDLCString flavorStr;
flavor->ToString(getter_Copies(flavorStr));
// special case text/unicode since we can handle all of
// the string types
if (!strcmp(flavorStr, kUnicodeMime)) {
gtk_target_list_add(list, gdk_atom_intern("UTF8_STRING", FALSE), 0, 0);
gtk_target_list_add(list, gdk_atom_intern("COMPOUND_TEXT", FALSE), 0, 0);
gtk_target_list_add(list, gdk_atom_intern("TEXT", FALSE), 0, 0);
gtk_target_list_add(list, GDK_SELECTION_TYPE_STRING, 0, 0);
continue;
}
if (flavorStr.EqualsLiteral(kNativeImageMime) ||
flavorStr.EqualsLiteral(kPNGImageMime) ||
flavorStr.EqualsLiteral(kJPEGImageMime) ||
flavorStr.EqualsLiteral(kGIFImageMime)) {
// don't bother adding image targets twice
if (!imagesAdded) {
// accept any writable image type
gtk_target_list_add_image_targets(list, 0, TRUE);
imagesAdded = PR_TRUE;
}
continue;
}
// Add this to our list of valid targets
GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
gtk_target_list_add(list, atom, 0, 0);
}
}
// Get GTK clipboard (CLIPBOARD or PRIMARY)
GtkClipboard *gtkClipboard = gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
gint numTargets;
GtkTargetEntry *gtkTargets = gtk_target_table_new_from_list(list, &numTargets);
// Set getcallback and request to store data after an application exit
if (gtk_clipboard_set_with_data(gtkClipboard, gtkTargets, numTargets,
clipboard_get_cb, clipboard_clear_cb, this))
{
// We managed to set-up the clipboard so update internal state
// We have to set it now because gtk_clipboard_set_with_data() calls clipboard_clear_cb()
// which reset our internal state
if (aWhichClipboard == kSelectionClipboard) {
mSelectionOwner = aOwner;
mSelectionTransferable = aTransferable;
}
else {
mGlobalOwner = aOwner;
mGlobalTransferable = aTransferable;
gtk_clipboard_set_can_store(gtkClipboard, gtkTargets, numTargets);
}
rv = NS_OK;
}
else {
rv = NS_ERROR_FAILURE;
}
gtk_target_table_free(gtkTargets, numTargets);
gtk_target_list_unref(list);
return rv;
}
static UINT remmina_rdp_cliprdr_server_format_list(CliprdrClientContext* context, CLIPRDR_FORMAT_LIST* formatList)
{
TRACE_CALL(__func__);
/* Called when a user do a "Copy" on the server: we collect all formats
* the server send us and then setup the local clipboard with the appropiate
* functions to request server data */
RemminaPluginRdpUiObject* ui;
RemminaProtocolWidget* gp;
rfClipboard* clipboard;
CLIPRDR_FORMAT* format;
CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse;
int i;
clipboard = (rfClipboard*)context->custom;
gp = clipboard->rfi->protocol_widget;
GtkTargetList* list = gtk_target_list_new(NULL, 0);
for (i = 0; i < formatList->numFormats; i++) {
format = &formatList->formats[i];
if (format->formatId == CF_UNICODETEXT) {
GdkAtom atom = gdk_atom_intern("UTF8_STRING", TRUE);
gtk_target_list_add(list, atom, 0, CF_UNICODETEXT);
}else if (format->formatId == CF_TEXT) {
GdkAtom atom = gdk_atom_intern("TEXT", TRUE);
gtk_target_list_add(list, atom, 0, CF_TEXT);
}else if (format->formatId == CF_DIB) {
GdkAtom atom = gdk_atom_intern("image/bmp", TRUE);
gtk_target_list_add(list, atom, 0, CF_DIB);
}else if (format->formatId == CF_DIBV5) {
GdkAtom atom = gdk_atom_intern("image/bmp", TRUE);
gtk_target_list_add(list, atom, 0, CF_DIBV5);
}else if (format->formatId == CB_FORMAT_JPEG) {
GdkAtom atom = gdk_atom_intern("image/jpeg", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_JPEG);
}else if (format->formatId == CB_FORMAT_PNG) {
GdkAtom atom = gdk_atom_intern("image/png", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_PNG);
}else if (format->formatId == CB_FORMAT_HTML) {
GdkAtom atom = gdk_atom_intern("text/html", TRUE);
gtk_target_list_add(list, atom, 0, CB_FORMAT_HTML);
}
}
/* Now we tell GTK to change the local keyboard calling gtk_clipboard_set_with_owner
* via REMMINA_RDP_UI_CLIPBOARD_SET_DATA
* GTK will immediately fire an "owner-change" event, that we should ignore */
ui = g_new0(RemminaPluginRdpUiObject, 1);
ui->type = REMMINA_RDP_UI_CLIPBOARD;
ui->clipboard.clipboard = clipboard;
ui->clipboard.type = REMMINA_RDP_UI_CLIPBOARD_SET_DATA;
ui->clipboard.targetlist = list;
remmina_rdp_event_queue_ui_sync_retint(gp, ui);
/* Send FormatListResponse to server */
formatListResponse.msgType = CB_FORMAT_LIST_RESPONSE;
formatListResponse.msgFlags = CB_RESPONSE_OK; // Can be CB_RESPONSE_FAIL in case of error
formatListResponse.dataLen = 0;
return clipboard->context->ClientFormatListResponse(clipboard->context, &formatListResponse);
}
PasteboardHelperGtk::PasteboardHelperGtk()
: m_targetList(gtk_target_list_new(0, 0))
{
gtk_target_list_add_text_targets(m_targetList, WEBKIT_WEB_VIEW_TARGET_INFO_TEXT);
gtk_target_list_add(m_targetList, gdkMarkupAtom, 0, WEBKIT_WEB_VIEW_TARGET_INFO_HTML);
}
void selection_to_clip(void)
{
struct XojSelectionData *sel;
int bufsz, nitems, val;
char *p;
GList *list;
struct Item *item;
GtkTargetList *targetlist;
GtkTargetEntry *targets;
int n_targets;
if (ui.selection == NULL) return;
bufsz = 2*sizeof(int) // bufsz, nitems
+ sizeof(struct BBox); // bbox
nitems = 0;
for (list = ui.selection->items; list != NULL; list = list->next) {
item = (struct Item *)list->data;
nitems++;
if (item->type == ITEM_STROKE) {
bufsz+= sizeof(int) // type
+ sizeof(struct Brush) // brush
+ sizeof(int) // num_points
+ 2*item->path->num_points*sizeof(double); // the points
if (item->brush.variable_width)
bufsz += (item->path->num_points-1)*sizeof(double); // the widths
}
else if (item->type == ITEM_TEXT) {
bufsz+= sizeof(int) // type
+ sizeof(struct Brush) // brush
+ 2*sizeof(double) // bbox upper-left
+ sizeof(int) // text len
+ strlen(item->text)+1 // text
+ sizeof(int) // font_name len
+ strlen(item->font_name)+1 // font_name
+ sizeof(double); // font_size
}
else if (item->type == ITEM_IMAGE) {
if (item->image_png == NULL) {
set_cursor_busy(TRUE);
if (!gdk_pixbuf_save_to_buffer(item->image, &item->image_png, &item->image_png_len, "png", NULL, NULL))
item->image_png_len = 0; // failed for some reason, so forget it
set_cursor_busy(FALSE);
}
bufsz+= sizeof(int) // type
+ sizeof(struct BBox)
+ sizeof(gsize) // png_buflen
+ item->image_png_len;
}
else bufsz+= sizeof(int); // type
}
// allocate selection data structure and buffer
sel = g_malloc(sizeof(struct XojSelectionData));
sel->xo_data_len = bufsz;
sel->xo_data = g_malloc(bufsz);
sel->image_data = NULL;
sel->text_data = NULL;
// fill in the data
p = sel->xo_data;
g_memmove(p, &bufsz, sizeof(int)); p+= sizeof(int);
g_memmove(p, &nitems, sizeof(int)); p+= sizeof(int);
g_memmove(p, &ui.selection->bbox, sizeof(struct BBox)); p+= sizeof(struct BBox);
for (list = ui.selection->items; list != NULL; list = list->next) {
item = (struct Item *)list->data;
g_memmove(p, &item->type, sizeof(int)); p+= sizeof(int);
if (item->type == ITEM_STROKE) {
g_memmove(p, &item->brush, sizeof(struct Brush)); p+= sizeof(struct Brush);
g_memmove(p, &item->path->num_points, sizeof(int)); p+= sizeof(int);
g_memmove(p, item->path->coords, 2*item->path->num_points*sizeof(double));
p+= 2*item->path->num_points*sizeof(double);
if (item->brush.variable_width) {
g_memmove(p, item->widths, (item->path->num_points-1)*sizeof(double));
p+= (item->path->num_points-1)*sizeof(double);
}
}
if (item->type == ITEM_TEXT) {
g_memmove(p, &item->brush, sizeof(struct Brush)); p+= sizeof(struct Brush);
g_memmove(p, &item->bbox.left, sizeof(double)); p+= sizeof(double);
g_memmove(p, &item->bbox.top, sizeof(double)); p+= sizeof(double);
val = strlen(item->text);
g_memmove(p, &val, sizeof(int)); p+= sizeof(int);
g_memmove(p, item->text, val+1); p+= val+1;
val = strlen(item->font_name);
g_memmove(p, &val, sizeof(int)); p+= sizeof(int);
g_memmove(p, item->font_name, val+1); p+= val+1;
g_memmove(p, &item->font_size, sizeof(double)); p+= sizeof(double);
if (nitems==1) sel->text_data = g_strdup(item->text); // single text item
}
if (item->type == ITEM_IMAGE) {
g_memmove(p, &item->bbox, sizeof(struct BBox)); p+= sizeof(struct BBox);
g_memmove(p, &item->image_png_len, sizeof(gsize)); p+= sizeof(gsize);
if (item->image_png_len > 0) {
g_memmove(p, item->image_png, item->image_png_len); p+= item->image_png_len;
}
if (nitems==1) sel->image_data = gdk_pixbuf_copy(item->image); // single image
}
}
/* build list of valid targets */
targetlist = gtk_target_list_new(NULL, 0);
gtk_target_list_add(targetlist,
gdk_atom_intern(XOURNAL_TARGET_ATOM, FALSE), 0, TARGET_XOURNAL);
if (sel->image_data!=NULL)
gtk_target_list_add_image_targets(targetlist, TARGET_PIXBUF, TRUE);
if (sel->text_data!=NULL)
gtk_target_list_add_text_targets(targetlist, TARGET_TEXT);
targets = gtk_target_table_new_from_list(targetlist, &n_targets);
gtk_target_list_unref(targetlist);
gtk_clipboard_set_with_data(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
targets, n_targets,
callback_clipboard_get, callback_clipboard_clear, sel);
gtk_target_table_free(targets, n_targets);
}
wxDragResult wxDropSource::DoDragDrop(int flags)
{
wxCHECK_MSG( m_data && m_data->GetFormatCount(), wxDragNone,
wxT("Drop source: no data") );
// still in drag
if (g_blockEventsOnDrag)
return wxDragNone;
// don't start dragging if no button is down
if (g_lastButtonNumber == 0)
return wxDragNone;
// we can only start a drag after a mouse event
if (g_lastMouseEvent == NULL)
return wxDragNone;
// disabled for now
g_blockEventsOnDrag = true;
RegisterWindow();
m_waiting = true;
GtkTargetList *target_list = gtk_target_list_new( (GtkTargetEntry*) NULL, 0 );
wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
m_data->GetAllFormats( array );
size_t count = m_data->GetFormatCount();
for (size_t i = 0; i < count; i++)
{
GdkAtom atom = array[i];
#ifdef __WXDEBUG__
wxLogTrace(TRACE_DND, wxT("Drop source: Supported atom %s"), gdk_atom_name( atom ));
#endif
gtk_target_list_add( target_list, atom, 0, 0 );
}
delete[] array;
int action = GDK_ACTION_COPY;
if ( flags & wxDrag_AllowMove )
action |= GDK_ACTION_MOVE;
// VZ: as we already use g_blockEventsOnDrag it shouldn't be that bad
// to use a global to pass the flags to the drop target but I'd
// surely prefer a better way to do it
gs_flagsForDrag = flags;
GdkDragContext *context = gtk_drag_begin( m_widget,
target_list,
(GdkDragAction)action,
g_lastButtonNumber, // number of mouse button which started drag
(GdkEvent*) g_lastMouseEvent );
m_dragContext = context;
PrepareIcon( action, context );
while (m_waiting)
gtk_main_iteration();
m_retValue = ConvertFromGTK(context->action);
if ( m_retValue == wxDragNone )
m_retValue = wxDragCancel;
g_blockEventsOnDrag = false;
UnregisterWindow();
return m_retValue;
}
wxDragResult wxDropSource::DoDragDrop(int flags)
{
wxCHECK_MSG( m_data && m_data->GetFormatCount(), wxDragNone,
wxT("Drop source: no data") );
// still in drag
if (g_blockEventsOnDrag)
return wxDragNone;
// don't start dragging if no button is down
if (g_lastButtonNumber == 0)
return wxDragNone;
// we can only start a drag after a mouse event
if (g_lastMouseEvent == NULL)
return wxDragNone;
GTKConnectDragSignals();
wxON_BLOCK_EXIT_OBJ0(*this, wxDropSource::GTKDisconnectDragSignals);
m_waiting = true;
GtkTargetList *target_list = gtk_target_list_new( NULL, 0 );
wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
m_data->GetAllFormats( array );
size_t count = m_data->GetFormatCount();
for (size_t i = 0; i < count; i++)
{
GdkAtom atom = array[i];
wxLogTrace(TRACE_DND, wxT("Drop source: Supported atom %s"),
gdk_atom_name( atom ));
gtk_target_list_add( target_list, atom, 0, 0 );
}
delete[] array;
int allowed_actions = GDK_ACTION_COPY;
if ( flags & wxDrag_AllowMove )
allowed_actions |= GDK_ACTION_MOVE;
// VZ: as we already use g_blockEventsOnDrag it shouldn't be that bad
// to use a global to pass the flags to the drop target but I'd
// surely prefer a better way to do it
gs_flagsForDrag = flags;
m_retValue = wxDragCancel;
GdkDragContext *context = gtk_drag_begin( m_widget,
target_list,
(GdkDragAction)allowed_actions,
g_lastButtonNumber, // number of mouse button which started drag
(GdkEvent*) g_lastMouseEvent );
if ( !context )
{
// this can happen e.g. if gdk_pointer_grab() failed
return wxDragError;
}
m_dragContext = context;
PrepareIcon( allowed_actions, context );
while (m_waiting)
gtk_main_iteration();
g_signal_handlers_disconnect_by_func (m_iconWindow,
(gpointer) gtk_dnd_window_configure_callback, this);
return m_retValue;
}
