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             g_autoptr(GtkTargetList) list = NULL;
  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             if (targets) {
  98                 gd->cbowner[s] = true;
  99                 gtk_clipboard_set_with_data(gd->gtkcb[s],
 100                                             targets, n_targets,
 101                                             gd_clipboard_get_data,
 102                                             gd_clipboard_clear,
 103                                             gd);
 104
 105                 gtk_target_table_free(targets, n_targets);
 106             }
 107         }
 108         return;
 109     }
 110
 111     if (self_update) {
 112         return;
 113     }
 114
 115     /*
 116      * Clipboard got updated, with data probably.  No action here, we
 117      * are waiting for updates in gd_clipboard_get_data().
 118      */
 119 }
 120
 121 static void gd_clipboard_notify(Notifier *notifier, void *data)
 122 {
 123     GtkDisplayState *gd =
 124         container_of(notifier, GtkDisplayState, cbpeer.notifier);
 125     QemuClipboardNotify *notify = data;
 126
 127     switch (notify->type) {
 128     case QEMU_CLIPBOARD_UPDATE_INFO:
 129         gd_clipboard_update_info(gd, notify->info);
 130         return;
 131     case QEMU_CLIPBOARD_RESET_SERIAL:
 132         /* ignore */
 133         return;
 134     }
 135 }
 136
 137 static void gd_clipboard_request(QemuClipboardInfo *info,
 138                                  QemuClipboardType type)
 139 {
 140     GtkDisplayState *gd = container_of(info->owner, GtkDisplayState, cbpeer);
 141     char *text;
 142
 143     switch (type) {
 144     case QEMU_CLIPBOARD_TYPE_TEXT:
 145         text = gtk_clipboard_wait_for_text(gd->gtkcb[info->selection]);
 146         if (text) {
 147             qemu_clipboard_set_data(&gd->cbpeer, info, type,
 148                                     strlen(text), text, true);
 149             g_free(text);
 150         }
 151         break;
 152     default:
 153         break;
 154     }
 155 }
 156
 157 static void gd_owner_change(GtkClipboard *clipboard,
 158                             GdkEvent *event,
 159                             gpointer data)
 160 {
 161     GtkDisplayState *gd = data;
 162     QemuClipboardSelection s = gd_find_selection(gd, clipboard);
 163     QemuClipboardInfo *info;
 164
 165     if (gd->cbowner[s]) {
 166         /* ignore notifications about our own grabs */
 167         return;
 168     }
 169
 170
 171     switch (event->owner_change.reason) {
 172     case GDK_OWNER_CHANGE_NEW_OWNER:
 173         info = qemu_clipboard_info_new(&gd->cbpeer, s);
 174         if (gtk_clipboard_wait_is_text_available(clipboard)) {
 175             info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
 176         }
 177
 178         qemu_clipboard_update(info);
 179         qemu_clipboard_info_unref(info);
 180         break;
 181     default:
 182         qemu_clipboard_peer_release(&gd->cbpeer, s);
 183         gd->cbowner[s] = false;
 184         break;
 185     }
 186 }
 187
 188 void gd_clipboard_init(GtkDisplayState *gd)
 189 {
 190     gd->cbpeer.name = "gtk";
 191     gd->cbpeer.notifier.notify = gd_clipboard_notify;
 192     gd->cbpeer.request = gd_clipboard_request;
 193     qemu_clipboard_peer_register(&gd->cbpeer);
 194
 195     gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD] =
 196         gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 197     gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY] =
 198         gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 199     gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY] =
 200         gtk_clipboard_get(GDK_SELECTION_SECONDARY);
 201
 202     g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_CLIPBOARD],
 203                      "owner-change", G_CALLBACK(gd_owner_change), gd);
 204     g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_PRIMARY],
 205                      "owner-change", G_CALLBACK(gd_owner_change), gd);
 206     g_signal_connect(gd->gtkcb[QEMU_CLIPBOARD_SELECTION_SECONDARY],
 207                      "owner-change", G_CALLBACK(gd_owner_change), gd);
 208 }