/* FIXME bugzilla.gnome.org 47445: Needs to become a shared function */
static void
get_data_on_first_target_we_support (GtkWidget *widget, GdkDragContext *context, guint32 time, int x, int y)
{
GtkTargetList *list;
GdkAtom target;
if (drop_types_list == NULL) {
drop_types_list = gtk_target_list_new (drop_types,
G_N_ELEMENTS (drop_types) - 1);
gtk_target_list_add_text_targets (drop_types_list, NEMO_ICON_DND_TEXT);
}
if (drop_types_list_root == NULL) {
drop_types_list_root = gtk_target_list_new (drop_types,
G_N_ELEMENTS (drop_types));
gtk_target_list_add_text_targets (drop_types_list_root, NEMO_ICON_DND_TEXT);
}
if (nemo_icon_container_get_is_desktop (NEMO_ICON_CONTAINER (widget))) {
list = drop_types_list_root;
} else {
list = drop_types_list;
}
target = gtk_drag_dest_find_target (widget, context, list);
if (target != GDK_NONE) {
guint info;
NemoDragInfo *drag_info;
gboolean found;
drag_info = &(NEMO_ICON_CONTAINER (widget)->details->dnd_info->drag_info);
found = gtk_target_list_find (list, target, &info);
g_assert (found);
/* Don't get_data for destructive ops */
if ((info == NEMO_ICON_DND_ROOTWINDOW_DROP ||
info == NEMO_ICON_DND_XDNDDIRECTSAVE) &&
!drag_info->drop_occured) {
/* We can't call get_data here, because that would
make the source execute the rootwin action or the direct save */
drag_info->got_drop_data_type = TRUE;
drag_info->data_type = info;
} else {
if (info == NEMO_ICON_DND_XDNDDIRECTSAVE) {
set_direct_save_uri (widget, context, drag_info, x, y);
}
gtk_drag_get_data (GTK_WIDGET (widget), context,
target, time);
}
}
}
/*
* 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");
}
void Ctrl::DndTargets(GdkDragContext *context)
{
static Index<String> text_targets;
static Index<String> image_targets;
ONCELOCK {
GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (target_list, 0);
ToIndex(target_list, text_targets);
GtkTargetList *target_list2 = gtk_target_list_new (NULL, 0);
gtk_target_list_add_image_targets (target_list2, 0, TRUE);
ToIndex(target_list2, image_targets);
}
dnd_targets.Clear();
dnd_text_target.Clear();
for(GList *list = gdk_drag_context_list_targets(context); list; list = g_list_next (list)) {
String g = gdk_atom_name((GdkAtom)list->data);
if(text_targets.Find(g) >= 0) {
dnd_targets.Add("text");
if(dnd_text_target.IsEmpty())
dnd_text_target = g;
}
else if(image_targets.Find(g) >= 0) {
dnd_targets.Add("image");
if(dnd_image_target.IsEmpty())
dnd_image_target = g;
}
else
dnd_targets.Add(g);
}
}
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;
}
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);
}
void
dnd_init (GtkWidget * w)
{
GtkTargetList *tlist;
GtkTargetEntry *tgts;
gint ntgts;
tlist = gtk_target_list_new (NULL, 0);
gtk_target_list_add_uri_targets (tlist, 0);
gtk_target_list_add_text_targets (tlist, 0);
tgts = gtk_target_table_new_from_list (tlist, &ntgts);
gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, tgts, ntgts, GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (G_OBJECT (w), "drag_data_received", G_CALLBACK (drop_data_cb), NULL);
gtk_target_table_free (tgts, ntgts);
gtk_target_list_unref (tlist);
/* set tooltip */
if (options.dnd_data.tooltip)
{
GtkWidget *box;
box = gtk_dialog_get_content_area (GTK_DIALOG (w));
if (!options.data.no_markup)
gtk_widget_set_tooltip_markup (box, options.data.dialog_text);
else
gtk_widget_set_tooltip_text (box, options.data.dialog_text);
}
}
static void
take_xconsole_ownership(GtkWidget *widget, gpointer data)
{
char *name, hostname[255];
GdkAtom atom;
GtkClipboard *clipboard;
GtkTargetList *target_list;
GtkTargetEntry *targets;
int n_targets;
target_list = gtk_target_list_new(NULL, 0);
gtk_target_list_add_text_targets(target_list, 0);
targets = gtk_target_table_new_from_list (target_list, &n_targets);
gtk_target_list_unref(target_list);
memset(hostname, '\0', sizeof(hostname));
gethostname(hostname, sizeof(hostname) - 1);
name = g_strdup_printf("MIT_CONSOLE_%s", hostname);
atom = gdk_atom_intern(name, FALSE);
clipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(widget),
atom);
g_free(name);
gtk_clipboard_set_with_owner(clipboard,
targets,
n_targets,
clipboard_get,
(GtkClipboardClearFunc)gtk_main_quit,
G_OBJECT(widget));
}
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);
}
void
nautilus_drag_slot_proxy_init (GtkWidget *widget,
NautilusFile *target_file,
NautilusWindowSlot *target_slot)
{
NautilusDragSlotProxyInfo *drag_info;
const GtkTargetEntry targets[] = {
{ NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
{ NAUTILUS_ICON_DND_NETSCAPE_URL_TYPE, 0, NAUTILUS_ICON_DND_NETSCAPE_URL },
{ NAUTILUS_ICON_DND_XDNDDIRECTSAVE_TYPE, 0, NAUTILUS_ICON_DND_XDNDDIRECTSAVE }, /* XDS Protocol Type */
{ NAUTILUS_ICON_DND_RAW_TYPE, 0, NAUTILUS_ICON_DND_RAW }
};
GtkTargetList *target_list;
g_assert (GTK_IS_WIDGET (widget));
drag_info = g_slice_new0 (NautilusDragSlotProxyInfo);
g_object_set_data_full (G_OBJECT (widget), "drag-slot-proxy-data", drag_info,
drag_info_free);
drag_info->is_notebook = (g_object_get_data (G_OBJECT (widget), "nautilus-notebook-tab") != NULL);
if (target_file != NULL)
drag_info->target_file = nautilus_file_ref (target_file);
if (target_slot != NULL)
drag_info->target_slot = g_object_ref (target_slot);
drag_info->widget = widget;
gtk_drag_dest_set (widget, 0,
NULL, 0,
GDK_ACTION_MOVE |
GDK_ACTION_COPY |
GDK_ACTION_LINK |
GDK_ACTION_ASK);
target_list = gtk_target_list_new (targets, G_N_ELEMENTS (targets));
gtk_target_list_add_uri_targets (target_list, NAUTILUS_ICON_DND_URI_LIST);
gtk_target_list_add_text_targets (target_list, NAUTILUS_ICON_DND_TEXT);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
g_signal_connect (widget, "drag-motion",
G_CALLBACK (slot_proxy_drag_motion),
drag_info);
g_signal_connect (widget, "drag-drop",
G_CALLBACK (slot_proxy_drag_drop),
drag_info);
g_signal_connect (widget, "drag-data-received",
G_CALLBACK (slot_proxy_drag_data_received),
drag_info);
g_signal_connect (widget, "drag-leave",
G_CALLBACK (slot_proxy_drag_leave),
drag_info);
}
static void
gstyle_color_widget_init (GstyleColorWidget *self)
{
GtkStyleContext *context;
GtkWidget *widget = GTK_WIDGET (self);
gtk_widget_set_has_window (GTK_WIDGET (self), TRUE);
self->label = GTK_LABEL (g_object_new (GTK_TYPE_LABEL,
"ellipsize", PANGO_ELLIPSIZE_END,
"visible", TRUE,
"halign", GTK_ALIGN_CENTER,
"valign", GTK_ALIGN_CENTER,
NULL));
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (self->label));
self->is_name_visible = TRUE;
self->is_fallback_name_visible = TRUE;
self->fallback_name_kind = GSTYLE_COLOR_KIND_RGB_HEX6;
self->checkered_pattern = gstyle_utils_get_checkered_pattern ();
gtk_widget_set_valign (widget, GTK_ALIGN_FILL);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (widget, TRUE);
gtk_widget_set_vexpand (widget, TRUE);
context = gtk_widget_get_style_context (GTK_WIDGET (self));
self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context));
self->target_list = gtk_target_list_new (dnd_targets, G_N_ELEMENTS (dnd_targets));
gtk_target_list_add_text_targets (self->target_list, 0);
gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_MOVE);
gtk_drag_dest_set_target_list (widget, self->target_list);
gtk_drag_dest_set_track_motion (GTK_WIDGET (self), TRUE);
update_container_parent_informations (self);
self->multipress_gesture = gtk_gesture_multi_press_new (widget);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (self->multipress_gesture), 0);
gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (self->multipress_gesture),
GTK_PHASE_BUBBLE);
g_signal_connect (self->multipress_gesture, "pressed",
G_CALLBACK (gstyle_color_widget_multipress_gesture_pressed), widget);
self->drag_gesture = gtk_gesture_drag_new (GTK_WIDGET (self));
g_signal_connect (self->drag_gesture, "drag-update",
G_CALLBACK (gstyle_color_widget_drag_gesture_update), self);
g_signal_connect_swapped (self, "key-press-event",
G_CALLBACK (gstyle_color_widget_key_pressed_cb),
self);
gstyle_color_widget_actions_init (self);
gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
}
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;
}
static void
update_dest_target_list (GtkWidget *ebox)
{
GtkTargetList *target_list;
target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_image_targets (target_list, TARGET_IMAGE, FALSE);
gtk_target_list_add_text_targets (target_list, TARGET_TEXT);
gtk_drag_dest_set_target_list (ebox, target_list);
gtk_target_list_unref (target_list);
}
/**
* gtk_drag_dest_add_text_targets: (method)
* @widget: a #GtkWidget that’s a drag destination
*
* Add the text targets supported by #GtkSelectionData to
* the target list of the drag destination. The targets
* are added with @info = 0. If you need another value,
* use gtk_target_list_add_text_targets() and
* gtk_drag_dest_set_target_list().
*
* Since: 2.6
*/
void
gtk_drag_dest_add_text_targets (GtkWidget *widget)
{
GtkTargetList *target_list;
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list)
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (target_list, 0);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
void
nemo_icon_dnd_init (NemoIconContainer *container)
{
GtkTargetList *targets;
int n_elements;
g_return_if_fail (container != NULL);
g_return_if_fail (NEMO_IS_ICON_CONTAINER (container));
container->details->dnd_info = g_new0 (NemoIconDndInfo, 1);
nemo_drag_init (&container->details->dnd_info->drag_info,
drag_types, G_N_ELEMENTS (drag_types), TRUE);
/* Set up the widget as a drag destination.
* (But not a source, as drags starting from this widget will be
* implemented by dealing with events manually.)
*/
n_elements = G_N_ELEMENTS (drop_types);
if (!nemo_icon_container_get_is_desktop (container)) {
/* Don't set up rootwindow drop */
n_elements -= 1;
}
gtk_drag_dest_set (GTK_WIDGET (container),
0,
drop_types, n_elements,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list (GTK_WIDGET (container));
gtk_target_list_add_text_targets (targets, NEMO_ICON_DND_TEXT);
/* Messages for outgoing drag. */
g_signal_connect (container, "drag_begin",
G_CALLBACK (drag_begin_callback), NULL);
g_signal_connect (container, "drag_data_get",
G_CALLBACK (drag_data_get_callback), NULL);
g_signal_connect (container, "drag_end",
G_CALLBACK (drag_end_callback), NULL);
/* Messages for incoming drag. */
g_signal_connect (container, "drag_data_received",
G_CALLBACK (drag_data_received_callback), NULL);
g_signal_connect (container, "drag_motion",
G_CALLBACK (drag_motion_callback), NULL);
g_signal_connect (container, "drag_drop",
G_CALLBACK (drag_drop_callback), NULL);
g_signal_connect (container, "drag_leave",
G_CALLBACK (drag_leave_callback), NULL);
}
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
update_source_target_list (GtkWidget *ebox, GtkWidget *image)
{
GtkTargetList *target_list;
target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_image_targets (target_list, TARGET_IMAGE, FALSE);
if (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME)
gtk_target_list_add_text_targets (target_list, TARGET_TEXT);
gtk_drag_source_set_target_list (ebox, target_list);
gtk_target_list_unref (target_list);
}
void ptk_clipboard_cut_or_copy_files( const char* working_dir,
GList* files,
gboolean copy )
{
GtkClipboard * clip = gtk_clipboard_get( GDK_SELECTION_CLIPBOARD );
GtkTargetList* target_list = gtk_target_list_new( NULL, 0 );
GList* target;
gint i, n_targets;
GtkTargetEntry* targets;
GtkTargetPair* pair;
GList *l;
VFSFileInfo* file;
char* file_path;
GList* file_list = NULL;
gtk_target_list_add_text_targets( target_list, 0 );
n_targets = g_list_length( target_list->list ) + 2;
targets = g_new0( GtkTargetEntry, n_targets );
target = target_list->list;
for ( i = 0; target; ++i, target = g_list_next( target ) )
{
pair = ( GtkTargetPair* ) target->data;
targets[ i ].target = gdk_atom_name ( pair->target );
}
targets[ i ].target = "x-special/gnome-copied-files";
targets[ i + 1 ].target = "text/uri-list";
gtk_target_list_unref ( target_list );
for ( l = g_list_last( files ); l; l = l->prev ) //sfm was reverse order
{
file = ( VFSFileInfo* ) l->data;
file_path = g_build_filename( working_dir,
vfs_file_info_get_name( file ), NULL );
file_list = g_list_prepend( file_list, file_path );
}
gtk_clipboard_set_with_data ( clip, targets, n_targets,
clipboard_get_data,
clipboard_clean_data,
NULL );
g_free( targets );
clipboard_file_list = file_list;
clipboard_action = copy ? GDK_ACTION_COPY : GDK_ACTION_MOVE;
}
void
athena_drag_init (AthenaDragInfo *drag_info,
const GtkTargetEntry *drag_types,
int drag_type_count,
gboolean add_text_targets)
{
drag_info->target_list = gtk_target_list_new (drag_types,
drag_type_count);
if (add_text_targets) {
gtk_target_list_add_text_targets (drag_info->target_list,
ATHENA_ICON_DND_TEXT);
}
drag_info->drop_occured = FALSE;
drag_info->need_to_destroy = FALSE;
}
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
nautilus_drag_init (NautilusDragInfo *drag_info,
const GtkTargetEntry *drag_types,
int drag_type_count,
gboolean add_text_targets)
{
drag_info->target_list = gtk_target_list_new (drag_types,
drag_type_count);
if (add_text_targets) {
gtk_target_list_add_text_targets (drag_info->target_list,
NAUTILUS_ICON_DND_TEXT);
}
drag_info->drop_occured = FALSE;
drag_info->need_to_destroy = FALSE;
}
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);
}
void Ctrl::DndTargets(GdkDragContext *context)
{
static Index<String> text_targets;
static Index<String> image_targets;
static Index<String> files_targets;
ONCELOCK {
GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets(target_list, 0);
ToIndex(target_list, text_targets);
GtkTargetList *target_list2 = gtk_target_list_new (NULL, 0);
gtk_target_list_add_image_targets(target_list2, 0, TRUE);
ToIndex(target_list2, image_targets);
GtkTargetList *target_list3 = gtk_target_list_new (NULL, 0);
gtk_target_list_add_uri_targets(target_list3, 0);
ToIndex(target_list3, files_targets);
}
dnd_targets.Clear();
dnd_text_target.Clear();
#if GTK_CHECK_VERSION(2,22,0) // No drag&drop support before 2.22, sorry...
for(GList *list = gdk_drag_context_list_targets(context); list; list = g_list_next (list)) {
String g = gdk_atom_name((GdkAtom)list->data);
if(text_targets.Find(g) >= 0) {
dnd_targets.Add("text");
if(dnd_text_target.IsEmpty())
dnd_text_target = g;
}
else
if(image_targets.Find(g) >= 0) {
dnd_targets.Add("image");
if(dnd_image_target.IsEmpty())
dnd_image_target = g;
}
else
if(files_targets.Find(g) >= 0) {
dnd_targets.Add("files");
if(dnd_files_target.IsEmpty())
dnd_files_target = g;
}
else
dnd_targets.Add(g);
}
#endif
}
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;
}
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);
}
void SetupClipboardContentTypes()
{
GtkTargetList* list = gtk_target_list_new(NULL, 0);
// TODO: Support for images
if (!this->text && !this->uris)
return;
if (this->text)
gtk_target_list_add_text_targets(list, ClipboardPrivate::TEXT_DATA);
if (this->uris)
gtk_target_list_add_uri_targets(list, ClipboardPrivate::URI_LIST_DATA);
int size = 0;
GtkTargetEntry* table = gtk_target_table_new_from_list(list, &size);
if (table)
{
// gtk_clipboard_set_with_data may try to clear our clipboard when we
// call it, so we turn on a flag here which prevents our clipboard data
// from being freed during this call.
this->preserve = true;
GtkClipboard* clipboard = GetClipboard();
if (gtk_clipboard_set_with_data(clipboard, table, size, GetClipboardData,
ClearClipboardData, NULL))
{
this->ownClipboard = true;
gtk_clipboard_set_can_store(clipboard, NULL, 0);
}
this->preserve = false;
gtk_target_table_free(table, size);
}
gtk_target_list_unref(list);
}
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);
}
static VALUE
rg_add_text_targets(VALUE self, VALUE info)
{
gtk_target_list_add_text_targets(_SELF(self), NUM2UINT(info));
return self;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *button;
GIcon *icon;
GtkTargetList *tlist;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Gtk Entry Icons Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
table = gtk_table_new (2, 4, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
/*
* Open File - Sets the icon using a GIcon
*/
label = gtk_label_new ("Open File:");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
icon = g_themed_icon_new ("folder");
g_themed_icon_append_name (G_THEMED_ICON (icon), "gtk-directory");
gtk_entry_set_icon_from_gicon (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon);
gtk_entry_set_icon_sensitive (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
FALSE);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
"Open a file");
button = gtk_button_new_with_label ("Properties");
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), entry);
/*
* Save File - sets the icon using a stock id.
*/
label = gtk_label_new ("Save File:");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_entry_set_text (GTK_ENTRY (entry), "Right-to-left");
gtk_widget_set_direction (entry, GTK_TEXT_DIR_RTL);
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
GTK_STOCK_SAVE);
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
"Save a file");
tlist = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (tlist, 0);
gtk_entry_set_icon_drag_source (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
tlist, GDK_ACTION_COPY);
g_signal_connect_after (entry, "drag-begin",
G_CALLBACK (drag_begin_cb), NULL);
g_signal_connect (entry, "drag-data-get",
G_CALLBACK (drag_data_get_cb), NULL);
gtk_target_list_unref (tlist);
button = gtk_button_new_with_label ("Properties");
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), entry);
/*
* Search - Uses a helper function
*/
label = gtk_label_new ("Search:");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
GTK_STOCK_FIND);
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_signal_connect (entry, "icon-press", G_CALLBACK (clear_pressed), NULL);
button = gtk_button_new_with_label ("Properties");
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), entry);
/*
* Password - Sets the icon using a stock id
*/
label = gtk_label_new ("Password:"******"Properties");
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), entry);
/* Name - Does not set any icons. */
label = gtk_label_new ("Name:");
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
GTK_FILL, GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 4, 5,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
button = gtk_button_new_with_label ("Properties");
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 4, 5,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), entry);
gtk_widget_show_all (window);
gtk_main();
return 0;
}
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);
}
