1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
3 /* nemo-clipboard.c
4 *
5 * Nemo Clipboard support. For now, routines to support component cut
6 * and paste.
7 *
8 * Copyright (C) 1999, 2000 Free Software Foundaton
9 * Copyright (C) 2000, 2001 Eazel, Inc.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public License as
13 * published by the Free Software Foundation; either version 2 of the
14 * License, or (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
20 *
21 * You should have received a copy of the GNU Library General Public
22 * License along with this program; if not, write to the
23 * Free Software Foundation, Inc., 51 Franklin Street - Suite 500,
24 * Boston, MA 02110-1335, USA.
25 *
26 * Authors: Rebecca Schulman <rebecka@eazel.com>,
27 * Darin Adler <darin@bentspoon.com>
28 */
29
30 #include <config.h>
31 #include "nemo-clipboard.h"
32 #include "nemo-file-utilities.h"
33
34 #include <glib/gi18n.h>
35 #include <gtk/gtk.h>
36 #include <string.h>
37
38 typedef struct _TargetCallbackData TargetCallbackData;
39
40 typedef void (* SelectAllCallback) (gpointer target);
41 typedef void (* ConnectCallbacksFunc) (GObject *object,
42 TargetCallbackData *target_data);
43
44 static void selection_changed_callback (GtkWidget *widget,
45 gpointer callback_data);
46 static void owner_change_callback (GtkClipboard *clipboard,
47 GdkEventOwnerChange *event,
48 gpointer callback_data);
49 struct _TargetCallbackData {
50 GtkUIManager *ui_manager;
51 GtkActionGroup *action_group;
52 gboolean shares_selection_changes;
53
54 SelectAllCallback select_all_callback;
55
56 ConnectCallbacksFunc connect_callbacks;
57 ConnectCallbacksFunc disconnect_callbacks;
58 };
59
60 static void
cut_callback(gpointer target)61 cut_callback (gpointer target)
62 {
63 g_assert (target != NULL);
64
65 g_signal_emit_by_name (target, "cut-clipboard");
66 }
67
68 static void
copy_callback(gpointer target)69 copy_callback (gpointer target)
70 {
71 g_assert (target != NULL);
72
73 g_signal_emit_by_name (target, "copy-clipboard");
74 }
75
76 static void
paste_callback(gpointer target)77 paste_callback (gpointer target)
78 {
79 g_assert (target != NULL);
80
81 g_signal_emit_by_name (target, "paste-clipboard");
82 }
83
84 static void
editable_select_all_callback(gpointer target)85 editable_select_all_callback (gpointer target)
86 {
87 GtkEditable *editable;
88
89 editable = GTK_EDITABLE (target);
90 g_assert (editable != NULL);
91
92 gtk_editable_set_position (editable, -1);
93 gtk_editable_select_region (editable, 0, -1);
94 }
95
96 static void
text_view_select_all_callback(gpointer target)97 text_view_select_all_callback (gpointer target)
98 {
99 g_assert (GTK_IS_TEXT_VIEW (target));
100
101 g_signal_emit_by_name (target, "select-all", TRUE);
102 }
103
104 static void
action_cut_callback(GtkAction * action,gpointer callback_data)105 action_cut_callback (GtkAction *action,
106 gpointer callback_data)
107 {
108 cut_callback (callback_data);
109 }
110
111 static void
action_copy_callback(GtkAction * action,gpointer callback_data)112 action_copy_callback (GtkAction *action,
113 gpointer callback_data)
114 {
115 copy_callback (callback_data);
116 }
117
118 static void
action_paste_callback(GtkAction * action,gpointer callback_data)119 action_paste_callback (GtkAction *action,
120 gpointer callback_data)
121 {
122 paste_callback (callback_data);
123 }
124
125 static void
action_select_all_callback(GtkAction * action,gpointer callback_data)126 action_select_all_callback (GtkAction *action,
127 gpointer callback_data)
128 {
129 TargetCallbackData *target_data;
130
131 g_assert (callback_data != NULL);
132
133 target_data = g_object_get_data (callback_data, "Nemo:clipboard_target_data");
134 g_assert (target_data != NULL);
135
136 target_data->select_all_callback (callback_data);
137 }
138
139 static void
received_clipboard_contents(GtkClipboard * clipboard,GtkSelectionData * selection_data,gpointer data)140 received_clipboard_contents (GtkClipboard *clipboard,
141 GtkSelectionData *selection_data,
142 gpointer data)
143 {
144 GtkActionGroup *action_group;
145 GtkAction *action;
146
147 action_group = data;
148
149 action = gtk_action_group_get_action (action_group,
150 "Paste");
151 if (action != NULL) {
152 gtk_action_set_sensitive (action,
153 gtk_selection_data_targets_include_text (selection_data));
154 }
155
156 g_object_unref (action_group);
157 }
158
159
160 static void
set_paste_sensitive_if_clipboard_contains_data(GtkActionGroup * action_group)161 set_paste_sensitive_if_clipboard_contains_data (GtkActionGroup *action_group)
162 {
163 GtkAction *action;
164 if (gdk_display_supports_selection_notification (gdk_display_get_default ())) {
165 gtk_clipboard_request_contents (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
166 gdk_atom_intern ("TARGETS", FALSE),
167 received_clipboard_contents,
168 g_object_ref (action_group));
169 } else {
170 /* If selection notification isn't supported, always activate Paste */
171 action = gtk_action_group_get_action (action_group,
172 "Paste");
173 gtk_action_set_sensitive (action, TRUE);
174 }
175 }
176
177 static void
set_clipboard_menu_items_sensitive(GtkActionGroup * action_group)178 set_clipboard_menu_items_sensitive (GtkActionGroup *action_group)
179 {
180 GtkAction *action;
181
182 action = gtk_action_group_get_action (action_group,
183 "Cut");
184 gtk_action_set_sensitive (action, TRUE);
185 action = gtk_action_group_get_action (action_group,
186 "Copy");
187 gtk_action_set_sensitive (action, TRUE);
188 }
189
190 static void
set_clipboard_menu_items_insensitive(GtkActionGroup * action_group)191 set_clipboard_menu_items_insensitive (GtkActionGroup *action_group)
192 {
193 GtkAction *action;
194
195 action = gtk_action_group_get_action (action_group,
196 "Cut");
197 gtk_action_set_sensitive (action, FALSE);
198 action = gtk_action_group_get_action (action_group,
199 "Copy");
200 gtk_action_set_sensitive (action, FALSE);
201 }
202
203 static gboolean
clipboard_items_are_merged_in(GtkWidget * widget)204 clipboard_items_are_merged_in (GtkWidget *widget)
205 {
206 return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
207 "Nemo:clipboard_menu_items_merged"));
208 }
209
210 static void
set_clipboard_items_are_merged_in(GObject * widget_as_object,gboolean merged_in)211 set_clipboard_items_are_merged_in (GObject *widget_as_object,
212 gboolean merged_in)
213 {
214 g_object_set_data (widget_as_object,
215 "Nemo:clipboard_menu_items_merged",
216 GINT_TO_POINTER (merged_in));
217 }
218
219 static void
editable_connect_callbacks(GObject * object,TargetCallbackData * target_data)220 editable_connect_callbacks (GObject *object,
221 TargetCallbackData *target_data)
222 {
223 g_signal_connect_after (object, "selection_changed",
224 G_CALLBACK (selection_changed_callback), target_data);
225 selection_changed_callback (GTK_WIDGET (object),
226 target_data);
227 }
228
229 static void
editable_disconnect_callbacks(GObject * object,TargetCallbackData * target_data)230 editable_disconnect_callbacks (GObject *object,
231 TargetCallbackData *target_data)
232 {
233 g_signal_handlers_disconnect_matched (object,
234 G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
235 0, 0, NULL,
236 G_CALLBACK (selection_changed_callback),
237 target_data);
238 }
239
240 static void
text_buffer_update_sensitivity(GtkTextBuffer * buffer,TargetCallbackData * target_data)241 text_buffer_update_sensitivity (GtkTextBuffer *buffer,
242 TargetCallbackData *target_data)
243 {
244 g_assert (GTK_IS_TEXT_BUFFER (buffer));
245 g_assert (target_data != NULL);
246
247 if (gtk_text_buffer_get_selection_bounds (buffer, NULL, NULL)) {
248 set_clipboard_menu_items_sensitive (target_data->action_group);
249 } else {
250 set_clipboard_menu_items_insensitive (target_data->action_group);
251 }
252 }
253
254 static void
text_buffer_delete_range(GtkTextBuffer * buffer,GtkTextIter * iter1,GtkTextIter * iter2,TargetCallbackData * target_data)255 text_buffer_delete_range (GtkTextBuffer *buffer,
256 GtkTextIter *iter1,
257 GtkTextIter *iter2,
258 TargetCallbackData *target_data)
259 {
260 text_buffer_update_sensitivity (buffer, target_data);
261 }
262
263 static void
text_buffer_mark_set(GtkTextBuffer * buffer,GtkTextIter * iter,GtkTextMark * mark,TargetCallbackData * target_data)264 text_buffer_mark_set (GtkTextBuffer *buffer,
265 GtkTextIter *iter,
266 GtkTextMark *mark,
267 TargetCallbackData *target_data)
268 {
269 /* anonymous marks with NULL names refer to cursor moves */
270 if (gtk_text_mark_get_name (mark) != NULL) {
271 text_buffer_update_sensitivity (buffer, target_data);
272 }
273 }
274
275 static void
text_view_connect_callbacks(GObject * object,TargetCallbackData * target_data)276 text_view_connect_callbacks (GObject *object,
277 TargetCallbackData *target_data)
278 {
279 GtkTextBuffer *buffer;
280
281 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (object));
282 g_assert (buffer);
283
284 g_signal_connect_after (buffer, "mark-set",
285 G_CALLBACK (text_buffer_mark_set), target_data);
286 g_signal_connect_after (buffer, "delete-range",
287 G_CALLBACK (text_buffer_delete_range), target_data);
288 text_buffer_update_sensitivity (buffer, target_data);
289 }
290
291 static void
text_view_disconnect_callbacks(GObject * object,TargetCallbackData * target_data)292 text_view_disconnect_callbacks (GObject *object,
293 TargetCallbackData *target_data)
294 {
295 GtkTextBuffer *buffer;
296
297 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (object));
298 g_assert (buffer);
299
300 g_signal_handlers_disconnect_matched (buffer,
301 G_SIGNAL_MATCH_DATA,
302 0, 0, NULL, NULL,
303 target_data);
304 }
305
306 static void
merge_in_clipboard_menu_items(GObject * widget_as_object,TargetCallbackData * target_data)307 merge_in_clipboard_menu_items (GObject *widget_as_object,
308 TargetCallbackData *target_data)
309 {
310 gboolean add_selection_callback;
311
312 g_assert (target_data != NULL);
313
314 add_selection_callback = target_data->shares_selection_changes;
315
316 gtk_ui_manager_insert_action_group (target_data->ui_manager,
317 target_data->action_group, 0);
318
319 set_paste_sensitive_if_clipboard_contains_data (target_data->action_group);
320
321 g_signal_connect (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), "owner_change",
322 G_CALLBACK (owner_change_callback), target_data);
323
324 if (add_selection_callback) {
325 target_data->connect_callbacks (widget_as_object, target_data);
326 } else {
327 /* If we don't use sensitivity, everything should be on */
328 set_clipboard_menu_items_sensitive (target_data->action_group);
329 }
330 set_clipboard_items_are_merged_in (widget_as_object, TRUE);
331 }
332
333 static void
merge_out_clipboard_menu_items(GObject * widget_as_object,TargetCallbackData * target_data)334 merge_out_clipboard_menu_items (GObject *widget_as_object,
335 TargetCallbackData *target_data)
336
337 {
338 gboolean selection_callback_was_added;
339
340 g_assert (target_data != NULL);
341
342 gtk_ui_manager_remove_action_group (target_data->ui_manager,
343 target_data->action_group);
344
345 g_signal_handlers_disconnect_matched (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD),
346 G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
347 0, 0, NULL,
348 G_CALLBACK (owner_change_callback),
349 target_data);
350
351 selection_callback_was_added = target_data->shares_selection_changes;
352
353 if (selection_callback_was_added) {
354 target_data->disconnect_callbacks (widget_as_object, target_data);
355 }
356 set_clipboard_items_are_merged_in (widget_as_object, FALSE);
357 }
358
359 static gboolean
focus_changed_callback(GtkWidget * widget,GdkEventAny * event,gpointer callback_data)360 focus_changed_callback (GtkWidget *widget,
361 GdkEventAny *event,
362 gpointer callback_data)
363 {
364 /* Connect the component to the container if the widget has focus. */
365 if (gtk_widget_has_focus (widget)) {
366 if (!clipboard_items_are_merged_in (widget)) {
367 merge_in_clipboard_menu_items (G_OBJECT (widget), callback_data);
368 }
369 } else {
370 if (clipboard_items_are_merged_in (widget)) {
371 merge_out_clipboard_menu_items (G_OBJECT (widget), callback_data);
372 }
373 }
374
375 return FALSE;
376 }
377
378 static void
selection_changed_callback(GtkWidget * widget,gpointer callback_data)379 selection_changed_callback (GtkWidget *widget,
380 gpointer callback_data)
381 {
382 TargetCallbackData *target_data;
383 GtkEditable *editable;
384 int start, end;
385
386 target_data = (TargetCallbackData *) callback_data;
387 g_assert (target_data != NULL);
388
389 editable = GTK_EDITABLE (widget);
390 g_assert (editable != NULL);
391
392 if (gtk_editable_get_selection_bounds (editable, &start, &end) && start != end) {
393 set_clipboard_menu_items_sensitive (target_data->action_group);
394 } else {
395 set_clipboard_menu_items_insensitive (target_data->action_group);
396 }
397 }
398
399 static void
owner_change_callback(GtkClipboard * clipboard,GdkEventOwnerChange * event,gpointer callback_data)400 owner_change_callback (GtkClipboard *clipboard,
401 GdkEventOwnerChange *event,
402 gpointer callback_data)
403 {
404 TargetCallbackData *target_data;
405
406 g_assert (callback_data != NULL);
407 target_data = callback_data;
408
409 set_paste_sensitive_if_clipboard_contains_data (target_data->action_group);
410 }
411
412 static void
target_destroy_callback(GtkWidget * object,gpointer callback_data)413 target_destroy_callback (GtkWidget *object,
414 gpointer callback_data)
415 {
416 g_assert (callback_data != NULL);
417
418 if (clipboard_items_are_merged_in (object)) {
419 merge_out_clipboard_menu_items (G_OBJECT (object), callback_data);
420 }
421 }
422
423 static void
target_data_free(TargetCallbackData * target_data)424 target_data_free (TargetCallbackData *target_data)
425 {
426 g_object_unref (target_data->action_group);
427 g_free (target_data);
428 }
429
430 static const GtkActionEntry clipboard_entries[] = {
431 /* name, stock id */ { "Cut", GTK_STOCK_CUT,
432 /* label, accelerator */ NULL, NULL,
433 /* tooltip */ N_("Cut the selected text to the clipboard"),
434 G_CALLBACK (action_cut_callback) },
435 /* name, stock id */ { "Copy", GTK_STOCK_COPY,
436 /* label, accelerator */ NULL, NULL,
437 /* tooltip */ N_("Copy the selected text to the clipboard"),
438 G_CALLBACK (action_copy_callback) },
439 /* name, stock id */ { "Paste", GTK_STOCK_PASTE,
440 /* label, accelerator */ NULL, NULL,
441 /* tooltip */ N_("Paste the text stored on the clipboard"),
442 G_CALLBACK (action_paste_callback) },
443 /* name, stock id */ { "Select All", NULL,
444 /* label, accelerator */ N_("Select _All"), "<control>A",
445 /* tooltip */ N_("Select all the text in a text field"),
446 G_CALLBACK (action_select_all_callback) },
447 };
448
449 static TargetCallbackData *
initialize_clipboard_component_with_callback_data(GtkEditable * target,GtkUIManager * ui_manager,gboolean shares_selection_changes,SelectAllCallback select_all_callback,ConnectCallbacksFunc connect_callbacks,ConnectCallbacksFunc disconnect_callbacks)450 initialize_clipboard_component_with_callback_data (GtkEditable *target,
451 GtkUIManager *ui_manager,
452 gboolean shares_selection_changes,
453 SelectAllCallback select_all_callback,
454 ConnectCallbacksFunc connect_callbacks,
455 ConnectCallbacksFunc disconnect_callbacks)
456 {
457 GtkActionGroup *action_group;
458 TargetCallbackData *target_data;
459
460 action_group = gtk_action_group_new ("ClipboardActions");
461 gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
462 gtk_action_group_add_actions (action_group,
463 clipboard_entries, G_N_ELEMENTS (clipboard_entries),
464 target);
465
466 /* Do the actual connection of the UI to the container at
467 * focus time, and disconnect at both focus and destroy
468 * time.
469 */
470 target_data = g_new (TargetCallbackData, 1);
471 target_data->ui_manager = ui_manager;
472 target_data->action_group = action_group;
473 target_data->shares_selection_changes = shares_selection_changes;
474 target_data->select_all_callback = select_all_callback;
475 target_data->connect_callbacks = connect_callbacks;
476 target_data->disconnect_callbacks = disconnect_callbacks;
477
478 return target_data;
479 }
480
481 static void
nemo_clipboard_real_set_up(gpointer target,GtkUIManager * ui_manager,gboolean shares_selection_changes,SelectAllCallback select_all_callback,ConnectCallbacksFunc connect_callbacks,ConnectCallbacksFunc disconnect_callbacks)482 nemo_clipboard_real_set_up (gpointer target,
483 GtkUIManager *ui_manager,
484 gboolean shares_selection_changes,
485 SelectAllCallback select_all_callback,
486 ConnectCallbacksFunc connect_callbacks,
487 ConnectCallbacksFunc disconnect_callbacks)
488 {
489 TargetCallbackData *target_data;
490
491 if (g_object_get_data (G_OBJECT (target), "Nemo:clipboard_target_data") != NULL) {
492 return;
493 }
494
495 target_data = initialize_clipboard_component_with_callback_data
496 (target,
497 ui_manager,
498 shares_selection_changes,
499 select_all_callback,
500 connect_callbacks,
501 disconnect_callbacks);
502
503 g_signal_connect (target, "focus_in_event",
504 G_CALLBACK (focus_changed_callback), target_data);
505 g_signal_connect (target, "focus_out_event",
506 G_CALLBACK (focus_changed_callback), target_data);
507 g_signal_connect (target, "destroy",
508 G_CALLBACK (target_destroy_callback), target_data);
509
510 g_object_set_data_full (G_OBJECT (target), "Nemo:clipboard_target_data",
511 target_data, (GDestroyNotify) target_data_free);
512
513 /* Call the focus changed callback once to merge if the window is
514 * already in focus.
515 */
516 focus_changed_callback (GTK_WIDGET (target), NULL, target_data);
517 }
518
519 void
nemo_clipboard_set_up_editable(GtkEditable * target,GtkUIManager * ui_manager,gboolean shares_selection_changes)520 nemo_clipboard_set_up_editable (GtkEditable *target,
521 GtkUIManager *ui_manager,
522 gboolean shares_selection_changes)
523 {
524 g_return_if_fail (GTK_IS_EDITABLE (target));
525 g_return_if_fail (GTK_IS_UI_MANAGER (ui_manager));
526
527 nemo_clipboard_real_set_up (target, ui_manager,
528 shares_selection_changes,
529 editable_select_all_callback,
530 editable_connect_callbacks,
531 editable_disconnect_callbacks);
532 }
533
534 void
nemo_clipboard_set_up_text_view(GtkTextView * target,GtkUIManager * ui_manager)535 nemo_clipboard_set_up_text_view (GtkTextView *target,
536 GtkUIManager *ui_manager)
537 {
538 g_return_if_fail (GTK_IS_TEXT_VIEW (target));
539 g_return_if_fail (GTK_IS_UI_MANAGER (ui_manager));
540
541 nemo_clipboard_real_set_up (target, ui_manager, TRUE,
542 text_view_select_all_callback,
543 text_view_connect_callbacks,
544 text_view_disconnect_callbacks);
545 }
546
547 static GList *
convert_lines_to_str_list(char ** lines,gboolean * cut)548 convert_lines_to_str_list (char **lines, gboolean *cut)
549 {
550 int i;
551 GList *result;
552
553 if (cut) {
554 *cut = FALSE;
555 }
556
557 if (lines[0] == NULL) {
558 return NULL;
559 }
560
561 if (strcmp (lines[0], "cut") == 0) {
562 if (cut) {
563 *cut = TRUE;
564 }
565 } else if (strcmp (lines[0], "copy") != 0) {
566 return NULL;
567 }
568
569 result = NULL;
570 for (i = 1; lines[i] != NULL; i++) {
571 result = g_list_prepend (result, g_strdup (lines[i]));
572 }
573 return g_list_reverse (result);
574 }
575
576 GList*
nemo_clipboard_get_uri_list_from_selection_data(GtkSelectionData * selection_data,gboolean * cut,GdkAtom copied_files_atom)577 nemo_clipboard_get_uri_list_from_selection_data (GtkSelectionData *selection_data,
578 gboolean *cut,
579 GdkAtom copied_files_atom)
580 {
581 GList *items;
582 char **lines;
583
584 if (gtk_selection_data_get_data_type (selection_data) != copied_files_atom
585 || gtk_selection_data_get_length (selection_data) <= 0) {
586 items = NULL;
587 } else {
588 gchar *data;
589 /* Not sure why it's legal to assume there's an extra byte
590 * past the end of the selection data that it's safe to write
591 * to. But gtk_editable_selection_received does this, so I
592 * think it is OK.
593 */
594 data = (gchar *) gtk_selection_data_get_data (selection_data);
595 data[gtk_selection_data_get_length (selection_data)] = '\0';
596 lines = g_strsplit (data, "\n", 0);
597 items = convert_lines_to_str_list (lines, cut);
598 g_strfreev (lines);
599 }
600
601 return items;
602 }
603
604 GtkClipboard *
nemo_clipboard_get(GtkWidget * widget)605 nemo_clipboard_get (GtkWidget *widget)
606 {
607 return gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (widget)),
608 GDK_SELECTION_CLIPBOARD);
609 }
610
611 void
nemo_clipboard_clear_if_colliding_uris(GtkWidget * widget,const GList * item_uris,GdkAtom copied_files_atom)612 nemo_clipboard_clear_if_colliding_uris (GtkWidget *widget,
613 const GList *item_uris,
614 GdkAtom copied_files_atom)
615 {
616 GtkSelectionData *data;
617 GList *clipboard_item_uris, *l;
618 gboolean collision;
619
620 collision = FALSE;
621 data = gtk_clipboard_wait_for_contents (nemo_clipboard_get (widget),
622 copied_files_atom);
623 if (data == NULL) {
624 return;
625 }
626
627 clipboard_item_uris = nemo_clipboard_get_uri_list_from_selection_data (data, NULL,
628 copied_files_atom);
629
630 for (l = (GList *) item_uris; l; l = l->next) {
631 if (g_list_find_custom ((GList *) item_uris, l->data,
632 (GCompareFunc) g_strcmp0)) {
633 collision = TRUE;
634 break;
635 }
636 }
637
638 if (collision) {
639 gtk_clipboard_clear (nemo_clipboard_get (widget));
640 }
641
642 if (clipboard_item_uris) {
643 g_list_free_full (clipboard_item_uris, g_free);
644 }
645 }
646