Pileus Git - ~andy/gtk/blob - demos/gtk-demo/clipboard.c

   1 /* Clipboard
   2  *
   3  * GtkClipboard is used for clipboard handling. This demo shows how to
   4  * copy and paste text to and from the clipboard.
   5  *
   6  * It also shows how to transfer images via the clipboard or via
   7  * drag-and-drop, and how to make clipboard contents persist after
   8  * the application exits. Clipboard persistence requires a clipboard
   9  * manager to run.
  10  */
  11
  12 #include <gtk/gtk.h>
  13 #include <string.h>
  14
  15 static GtkWidget *window = NULL;
  16
  17 void
  18 copy_button_clicked (GtkWidget *button,
  19                      gpointer   user_data)
  20 {
  21   GtkWidget *entry;
  22   GtkClipboard *clipboard;
  23
  24   entry = GTK_WIDGET (user_data);
  25
  26   /* Get the clipboard object */
  27   clipboard = gtk_widget_get_clipboard (entry,
  28                                         GDK_SELECTION_CLIPBOARD);
  29
  30   /* Set clipboard text */
  31   gtk_clipboard_set_text (clipboard, gtk_entry_get_text (GTK_ENTRY (entry)), -1);
  32 }
  33
  34 void
  35 paste_received (GtkClipboard *clipboard,
  36                 const gchar  *text,
  37                 gpointer      user_data)
  38 {
  39   GtkWidget *entry;
  40
  41   entry = GTK_WIDGET (user_data);
  42
  43   /* Set the entry text */
  44   if(text)
  45     gtk_entry_set_text (GTK_ENTRY (entry), text);
  46 }
  47
  48 void
  49 paste_button_clicked (GtkWidget *button,
  50                      gpointer   user_data)
  51 {
  52   GtkWidget *entry;
  53   GtkClipboard *clipboard;
  54
  55   entry = GTK_WIDGET (user_data);
  56
  57   /* Get the clipboard object */
  58   clipboard = gtk_widget_get_clipboard (entry,
  59                                         GDK_SELECTION_CLIPBOARD);
  60
  61   /* Request the contents of the clipboard, contents_received will be
  62      called when we do get the contents.
  63    */
  64   gtk_clipboard_request_text (clipboard,
  65                               paste_received, entry);
  66 }
  67
  68 static GdkPixbuf *
  69 get_image_pixbuf (GtkImage *image)
  70 {
  71   gchar *stock_id;
  72   GtkIconSize size;
  73
  74   switch (gtk_image_get_storage_type (image))
  75     {
  76     case GTK_IMAGE_PIXBUF:
  77       return g_object_ref (gtk_image_get_pixbuf (image));
  78     case GTK_IMAGE_STOCK:
  79       gtk_image_get_stock (image, &stock_id, &size);
  80       return gtk_widget_render_icon (GTK_WIDGET (image),
  81                                      stock_id, size, NULL);
  82     default:
  83       g_warning ("Image storage type %d not handled",
  84                  gtk_image_get_storage_type (image));
  85       return NULL;
  86     }
  87 }
  88
  89 static void
  90 drag_begin (GtkWidget      *widget,
  91             GdkDragContext *context,
  92             gpointer        data)
  93 {
  94   GdkPixbuf *pixbuf;
  95
  96   pixbuf = get_image_pixbuf (GTK_IMAGE (data));
  97   gtk_drag_set_icon_pixbuf (context, pixbuf, -2, -2);
  98   g_object_unref (pixbuf);
  99 }
 100
 101 void
 102 drag_data_get  (GtkWidget        *widget,
 103                 GdkDragContext   *context,
 104                 GtkSelectionData *selection_data,
 105                 guint             info,
 106                 guint             time,
 107                 gpointer          data)
 108 {
 109   GdkPixbuf *pixbuf;
 110
 111   pixbuf = get_image_pixbuf (GTK_IMAGE (data));
 112   gtk_selection_data_set_pixbuf (selection_data, pixbuf);
 113   g_object_unref (pixbuf);
 114 }
 115
 116 static void
 117 drag_data_received (GtkWidget        *widget,
 118                     GdkDragContext   *context,
 119                     gint              x,
 120                     gint              y,
 121                     GtkSelectionData *selection_data,
 122                     guint             info,
 123                     guint32           time,
 124                     gpointer          data)
 125 {
 126   GdkPixbuf *pixbuf;
 127
 128   if (selection_data->length > 0)
 129     {
 130       pixbuf = gtk_selection_data_get_pixbuf (selection_data);
 131       gtk_image_set_from_pixbuf (GTK_IMAGE (data), pixbuf);
 132       g_object_unref (pixbuf);
 133     }
 134 }
 135
 136 static void
 137 copy_image (GtkMenuItem *item,
 138             gpointer     data)
 139 {
 140   GtkClipboard *clipboard;
 141   GdkPixbuf *pixbuf;
 142
 143   clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
 144   pixbuf = get_image_pixbuf (GTK_IMAGE (data));
 145
 146   gtk_clipboard_set_image (clipboard, pixbuf);
 147   g_object_unref (pixbuf);
 148 }
 149
 150 static void
 151 paste_image (GtkMenuItem *item,
 152              gpointer     data)
 153 {
 154   GtkClipboard *clipboard;
 155   GdkPixbuf *pixbuf;
 156
 157   clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
 158   pixbuf = gtk_clipboard_wait_for_image (clipboard);
 159
 160   if (pixbuf)
 161     {
 162       gtk_image_set_from_pixbuf (GTK_IMAGE (data), pixbuf);
 163       g_object_unref (pixbuf);
 164     }
 165 }
 166
 167 static gboolean
 168 button_press (GtkWidget      *widget,
 169               GdkEventButton *button,
 170               gpointer        data)
 171 {
 172   GtkWidget *menu;
 173   GtkWidget *item;
 174
 175   if (button->button != 3)
 176     return FALSE;
 177
 178   menu = gtk_menu_new ();
 179
 180   item = gtk_image_menu_item_new_from_stock (GTK_STOCK_COPY, NULL);
 181   g_signal_connect (item, "activate", G_CALLBACK (copy_image), data);
 182   gtk_widget_show (item);
 183   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 184
 185   item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PASTE, NULL);
 186   g_signal_connect (item, "activate", G_CALLBACK (paste_image), data);
 187   gtk_widget_show (item);
 188   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 189
 190   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 3, button->time);
 191   return TRUE;
 192 }
 193
 194 GtkWidget *
 195 do_clipboard (GtkWidget *do_widget)
 196 {
 197   if (!window)
 198     {
 199       GtkWidget *vbox, *hbox;
 200       GtkWidget *label;
 201       GtkWidget *entry, *button;
 202       GtkWidget *ebox, *image;
 203       GtkClipboard *clipboard;
 204
 205       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 206       g_signal_connect (window, "destroy",
 207                         G_CALLBACK (gtk_widget_destroyed), &window);
 208
 209       vbox = gtk_vbox_new (FALSE, 0);
 210       gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
 211
 212       gtk_container_add (GTK_CONTAINER (window), vbox);
 213
 214       label = gtk_label_new ("\"Copy\" will copy the text\nin the entry to the clipboard");
 215
 216       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 217
 218       hbox = gtk_hbox_new (FALSE, 4);
 219       gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
 220       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 221
 222       /* Create the first entry */
 223       entry = gtk_entry_new ();
 224       gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 225
 226       /* Create the button */
 227       button = gtk_button_new_from_stock (GTK_STOCK_COPY);
 228       gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 229       g_signal_connect (button, "clicked",
 230                         G_CALLBACK (copy_button_clicked), entry);
 231
 232       label = gtk_label_new ("\"Paste\" will paste the text from the clipboard to the entry");
 233       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 234
 235       hbox = gtk_hbox_new (FALSE, 4);
 236       gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
 237       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 238
 239       /* Create the second entry */
 240       entry = gtk_entry_new ();
 241       gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 242
 243       /* Create the button */
 244       button = gtk_button_new_from_stock (GTK_STOCK_PASTE);
 245       gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 246       g_signal_connect (button, "clicked",
 247                         G_CALLBACK (paste_button_clicked), entry);
 248
 249       label = gtk_label_new ("Images can be transferred via the clipboard, too");
 250       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 251
 252       hbox = gtk_hbox_new (FALSE, 4);
 253       gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
 254       gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 255
 256       /* Create the first image */
 257       image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
 258                                         GTK_ICON_SIZE_BUTTON);
 259       ebox = gtk_event_box_new ();
 260       gtk_container_add (GTK_CONTAINER (ebox), image);
 261       gtk_container_add (GTK_CONTAINER (hbox), ebox);
 262
 263       /* make ebox a drag source */
 264       gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
 265       gtk_drag_source_add_image_targets (ebox);
 266       g_signal_connect (ebox, "drag-begin",
 267                         G_CALLBACK (drag_begin), image);
 268       g_signal_connect (ebox, "drag-data-get",
 269                         G_CALLBACK (drag_data_get), image);
 270
 271       /* accept drops on ebox */
 272       gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,
 273                          NULL, 0, GDK_ACTION_COPY);
 274       gtk_drag_dest_add_image_targets (ebox);
 275       g_signal_connect (ebox, "drag-data-received",
 276                         G_CALLBACK (drag_data_received), image);
 277
 278       /* context menu on ebox */
 279       g_signal_connect (ebox, "button-press-event",
 280                         G_CALLBACK (button_press), image);
 281
 282       /* Create the second image */
 283       image = gtk_image_new_from_stock (GTK_STOCK_STOP,
 284                                         GTK_ICON_SIZE_BUTTON);
 285       ebox = gtk_event_box_new ();
 286       gtk_container_add (GTK_CONTAINER (ebox), image);
 287       gtk_container_add (GTK_CONTAINER (hbox), ebox);
 288
 289       /* make ebox a drag source */
 290       gtk_drag_source_set (ebox, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY);
 291       gtk_drag_source_add_image_targets (ebox);
 292       g_signal_connect (ebox, "drag-begin",
 293                         G_CALLBACK (drag_begin), image);
 294       g_signal_connect (ebox, "drag-data-get",
 295                         G_CALLBACK (drag_data_get), image);
 296
 297       /* accept drops on ebox */
 298       gtk_drag_dest_set (ebox, GTK_DEST_DEFAULT_ALL,
 299                          NULL, 0, GDK_ACTION_COPY);
 300       gtk_drag_dest_add_image_targets (ebox);
 301       g_signal_connect (ebox, "drag-data-received",
 302                         G_CALLBACK (drag_data_received), image);
 303
 304       /* context menu on ebox */
 305       g_signal_connect (ebox, "button-press-event",
 306                         G_CALLBACK (button_press), image);
 307
 308       /* tell the clipboard manager to make the data persistent */
 309       clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
 310       gtk_clipboard_set_can_store (clipboard, NULL, 0);
 311     }
 312
 313   if (!GTK_WIDGET_VISIBLE (window))
 314     gtk_widget_show_all (window);
 315   else
 316     {
 317       gtk_widget_destroy (window);
 318       window = NULL;
 319     }
 320
 321   return window;
 322 }