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/main-loop.h"
  23
  24 #include "ui/gtk.h"
  25
  26 static QemuClipboardSelection gd_find_selection(GtkDisplayState *gd,
  27                                                 GtkClipboard *clipboard)
  28 {
  29     QemuClipboardSelection s;
  30
  31     for (s = 0; s < QEMU_CLIPBOARD_SELECTION__COUNT; s++) {
  32         if (gd->gtkcb[s] == clipboard) {
  33             return s;
  34         }
  35     }
  36     return QEMU_CLIPBOARD_SELECTION_CLIPBOARD;
  37 }
  38
  39 static void gd_clipboard_get_data(GtkClipboard     *clipboard,
  40                                   GtkSelectionData *selection_data,
  41                                   guint             selection_info,
  42                                   gpointer          data)
  43 {
  44     GtkDisplayState *gd = data;
  45     QemuClipboardSelection s = gd_find_selection(gd, clipboard);
  46     QemuClipboardType type = QEMU_CLIPBOARD_TYPE_TEXT;
  47     g_autoptr(QemuClipboardInfo) info = NULL;
  48
  49     info = qemu_clipboard_info_ref(qemu_clipboard_info(s));
  50
  51     qemu_clipboard_request(info, type);
  52     while (info == qemu_clipboard_info(s) &&
  53            info->types[type].available &&
  54            info->types[type].data == NULL) {
  55         main_loop_wait(false);
  56     }
  57
  58     if (info == qemu_clipboard_info(s) && gd->cbowner[s]) {
  59         gtk_selection_data_set_text(selection_data,
  60                                     info->types[type].data,
  61                                     info->types[type].size);
  62     } else {
  63         /* clipboard owner changed while waiting for the data */
  64     }
  65 }
  66
  67 static void gd_clipboard_clear(GtkClipboard *clipboard,
  68                                gpointer data)
  69 {
  70     GtkDisplayState *gd = data;
  71     QemuClipboardSelection s = gd_find_selection(gd, clipboard);
  72
  73     gd->cbowner[s] = false;
  74 }
  75
  76 static void gd_clipboard_update_info(GtkDisplayState *gd,
  77                                      QemuClipboardInfo *info)
  78 {
  79     QemuClipboardSelection s = info->selection;
  80     bool self_update = info->owner == &gd->cbpeer;
  81
  82     if (info != qemu_clipboard_info(s)) {
  83         gd->cbpending[s] = 0;
  84         if (!self_update) {
  85             g_autoptr(GtkTargetList) list = NULL;
  86             GtkTargetEntry *targets;
  87             gint n_targets;
  88
  89             list = gtk_target_list_new(NULL, 0);
  90             if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
  91                 gtk_target_list_add_text_targets(list, 0);
  92             }
  93             targets = gtk_target_table_new_from_list(list, &n_targets);
  94
  95             gtk_clipboard_clear(gd->gtkcb[s]);
  96             if (targets) {
  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             }
 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 }