ui/gtk-clipboard.c

   1 /*
   2  * GTK UI -- clipboard support
   3  *
   4  * Copyright (C) 2021 Gerd Hoffmann <kraxel@redhat.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "qemu-common.h"
  23 #include "qemu/main-loop.h"
  24
  25 #include "ui/gtk.h"
  26
  27 static QemuClipboardSelection gd_find_selection(GtkDisplayState *gd,
  28                                                 GtkClipboard *clipboard)
  29 {
  30     QemuClipboardSelection s;
  31
  32     for (s = 0; s < QEMU_CLIPBOARD_SELECTION__COUNT; s++) {
  33         if (gd->gtkcb[s] == clipboard) {
  34             return s;
  35         }
  36     }
  37     return QEMU_CLIPBOARD_SELECTION_CLIPBOARD;
  38 }
  39
  40 static void gd_clipboard_get_data(GtkClipboard     *clipboard,
  41                                   GtkSelectionData *selection_data,
  42                                   guint             selection_info,
  43                                   gpointer          data)
  44 {
  45     GtkDisplayState *gd = data;
  46     QemuClipboardSelection s = gd_find_selection(gd, clipboard);
  47     QemuClipboardType type = QEMU_CLIPBOARD_TYPE_TEXT;
  48     g_autoptr(QemuClipboardInfo) info = NULL;
  49
  50     info = qemu_clipboard_info_ref(qemu_clipboard_info(s));
  51
  52     qemu_clipboard_request(info, type);
  53     while (info == qemu_clipboard_info(s) &&
  54            info->types[type].available &&
  55            info->types[type].data == NULL) {
  56         main_loop_wait(false);
  57     }
  58
  59     if (info == qemu_clipboard_info(s) && gd->cbowner[s]) {
  60         gtk_selection_data_set_text(selection_data,
  61                                     info->types[type].data,
  62                                     info->types[type].size);
  63     } else {
  64         /* clipboard owner changed while waiting for the data */
  65     }
  66 }
  67
  68 static void gd_clipboard_clear(GtkClipboard *clipboard,
  69                                gpointer data)
  70 {
  71     GtkDisplayState *gd = data;
  72     QemuClipboardSelection s = gd_find_selection(gd, clipboard);
  73
  74     gd->cbowner[s] = false;
  75 }
  76
  77 static void gd_clipboard_update_info(GtkDisplayState *gd,
  78                                      QemuClipboardInfo *info)
  79 {
  80     QemuClipboardSelection s = info->selection;
  81     bool self_update = info->owner == &gd->cbpeer;
  82
  83     if (info != qemu_clipboard_info(s)) {
  84         gd->cbpending[s] = 0;
  85         if (!self_update) {
  86             GtkTargetList *list;
  87             GtkTargetEntry *targets;
  88             gint n_targets;
  89
  90             list = gtk_target_list_new(NULL, 0);
  91             if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
  92                 gtk_target_list_add_text_targets(list, 0);
  93             }
  94             targets = gtk_target_table_new_from_list(list, &n_targets);
  95
  96             gtk_clipboard_clear(gd->gtkcb[s]);
  97             gd->cbowner[s] = true;
  98             gtk_clipboard_set_with_data(gd->gtkcb[s],
  99                                         targets, n_targets,
 100                                         gd_clipboard_get_data,
 101                                         gd_clipboard_clear,
 102                                         gd);
 103
 104             gtk_target_table_free(targets, n_targets);
 105             gtk_target_list_unref(list);
 106         }
 107         return;
 108     }
 109
 110     if (self_update) {
 111         return;
 112     }
 113
 114     /*
 115      * Clipboard got updated, with data probably.  No action here, we
 116      * are waiting for updates in gd_clipboard_get_data().
 117      */
 118 }
 119
 120 static void gd_clipboard_notify(Notifier *notifier, void *data)
 121 {
 122     GtkDisplayState *gd =
 123         container_of(notifier, GtkDisplayState, cbpeer.notifier);
 124     QemuClipboardNotify *notify = data;
 125
 126     switch (notify->type) {
 127     case QEMU_CLIPBOARD_UPDATE_INFO:
 128         gd_clipboard_update_info(gd, notify->info);
 129         return;
 130     case QEMU_CLIPBOARD_RESET_SERIAL:
 131         /* ignore */
 132         return;
 133     }
 134 }
 135
 136 static void gd_clipboard_request(QemuClipboardInfo *info,
 137                                  QemuClipboardType type)
 138 {
 139     GtkDisplayState *gd = container_of(info->owner, GtkDisplayState, cbpeer);
 140     char *text;
 141
 142     switch (type) {
 143     case QEMU_CLIPBOARD_TYPE_TEXT:
 144         text = gtk_clipboard_wait_for_text(gd->gtkcb[info->selection]);
 145         if (text) {
 146             qemu_clipboard_set_data(&gd->cbpeer, info, type,
 147                                     strlen(text), text, true);
 148             g_free(text);
 149         }
 150         break;
 151     default:
 152         break;
 153     }
 154 }
 155
 156 static void gd_owner_change(GtkClipboard *clipboard,
 157                             GdkEvent *event,
 158                             gpointer data)
 159 {
 160     GtkDisplayState *gd = data;
 161     QemuClipboardSelection s = gd_find_selection(gd, clipboard);
 162     QemuClipboardInfo *info;
 163
 164     if (gd->cbowner[s]) {
 165         /* ignore notifications about our own grabs */
 166         return;
 167     }
 168
 169
 170     switch (event->owner_change.reason) {
 171     case GDK_OWNER_CHANGE_NEW_OWNER:
 172         info = qemu_clipboard_info_new(&gd->cbpeer, s);
 173         if (gtk_clipboard_wait_is_text_available(clipboard)) {
 174             info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
 175         }
 176
 177         qemu_clipboard_update(info);
 178         qemu_clipboard_info_unref(info);
 179         break;
 180     default:
 181         qemu_clipboard_peer_release(&gd->cbpeer, s);
 182         gd->cbowner[s] = false;
 183         break;
 184     }
 185 }
 186
 187 void gd_clipboard_init(GtkDisplayState *gd)
 188 {
 189     gd->cbpeer.name = "gtk";
 190     gd->cbpeer.notifier.notify = gd_clipboard_notify;
 191     gd->cbpeer.request = gd_clipboard_request;
 192     qemu_clipboard_peer_register(&gd->cbpeer);
 193
 194     gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD] =
 195         gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 196     gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY] =
 197         gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 198     gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY] =
 199         gtk_clipboard_get(GDK_SELECTION_SECONDARY);
 200
 201     g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD],
 202                      "owner-change", G_CALLBACK(gd_owner_change), gd);
 203     g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY],
 204                      "owner-change", G_CALLBACK(gd_owner_change), gd);
 205     g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY],
 206                      "owner-change", G_CALLBACK(gd_owner_change), gd);
 207 }